Khabib: ‘I don’t aim to hurt’ anyone, but I beat Conor McGregor ‘with pleasure’
by Milan OrdoñezKhabib Nurmagomedov is known as one of the most dominant fighters in the sport today. But according to the undefeated UFC lightweight champion, he never really enjoyed inflicting pain on his opponents.
“I had fights in my career where I understood that I could hurt my opponent more, but I’d talk to him, tell him to give up so that I don’t beat him too hard,” he said in his native language (via RT Sport).
“For example, if I had a painful hold where I could break something, I wouldn’t tighten it all the way. I’d just fix it so that the opponent would tap out. Because I have no aim to hurt anyone in this sport.
“Yes, we compete in a very brutal contact sport,” he added. “But it’s never my goal to inflict a lot of pain on my opponent. If I understand that I’m winning, I don’t aim to hurt someone bad.”
“The Eagle,” however, made an exception to this mindset for Conor McGregor, whom he says he took pleasure in beating.
“Well, with the exception of one fight. Let’s say in that fight, I beat that guy with pleasure, I’ll tell you.”
Khabib is still deciding on whom he will fight next, but he says there is a “95 percent chance” it would be Tony Ferguson.


|
|
@@ -45,7 +45,10 @@ public class IncomingSocketManager { |
|
|
|
|
|
/// The last time we checked for an idle socket
|
|
/// The last time we checked for an idle socket
|
|
var keepAliveIdleLastTimeChecked = Date()
|
|
var keepAliveIdleLastTimeChecked = Date()
|
|
-
|
|
+
|
|
|
|
+ /// Flag indicating when we are done using this socket manager, so we can clean up
|
|
|
|
+ private var stopped = false
|
|
|
|
+
|
|
#if !GCD_ASYNCH && os(Linux)
|
|
#if !GCD_ASYNCH && os(Linux)
|
|
private let maximumNumberOfEvents = 300
|
|
private let maximumNumberOfEvents = 300
|
|
|
|
|
|
|
@@ -55,7 +58,6 @@ public class IncomingSocketManager { |
|
private let queues:[DispatchQueue]
|
|
private let queues:[DispatchQueue]
|
|
|
|
|
|
let epollTimeout: Int32 = 50
|
|
let epollTimeout: Int32 = 50
|
|
- var runEpoll = true
|
|
|
|
|
|
|
|
private func epollDescriptor(fd:Int32) -> Int32 {
|
|
private func epollDescriptor(fd:Int32) -> Int32 {
|
|
return epollDescriptors[Int(fd) % numberOfEpollTasks];
|
|
return epollDescriptors[Int(fd) % numberOfEpollTasks];
|
|
|
@@ -82,11 +84,29 @@ public class IncomingSocketManager { |
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
|
|
|
|
+ deinit {
|
|
|
|
+ stop()
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ /// Stop this socket manager instance and cleanup resources.
|
|
|
|
+ /// If using epoll, it also ends the epoll process() task, closes the epoll fd and releases its thread.
|
|
|
|
+ public func stop() {
|
|
|
|
+ stopped = true
|
|
|
|
+ #if GCD_ASYNCH || !os(Linux)
|
|
|
|
+ removeIdleSockets(removeAll: true)
|
|
|
|
+ #endif
|
|
|
|
+ }
|
|
|
|
+
|
|
/// Handle a new incoming socket
|
|
/// Handle a new incoming socket
|
|
///
|
|
///
|
|
/// - Parameter socket: the incoming socket to handle
|
|
/// - Parameter socket: the incoming socket to handle
|
|
/// - Parameter using: The ServerDelegate to actually handle the socket
|
|
/// - Parameter using: The ServerDelegate to actually handle the socket
|
|
public func handle(socket: Socket, processor: IncomingSocketProcessor) {
|
|
public func handle(socket: Socket, processor: IncomingSocketProcessor) {
|
|
|
|
+ guard !stopped else {
|
|
|
|
+ Log.warning("Cannot handle socket as socket manager has been stopped")
|
|
|
|
+ return
|
|
|
|
+ }
|
|
|
|
+
|
|
do {
|
|
do {
|
|
try socket.setBlocking(mode: false)
|
|
try socket.setBlocking(mode: false)
|
|
|
|
|
|
|
@@ -117,7 +137,7 @@ public class IncomingSocketManager { |
|
var deferredHandlers = [Int32: IncomingSocketHandler]()
|
|
var deferredHandlers = [Int32: IncomingSocketHandler]()
|
|
var deferredHandlingNeeded = false
|
|
var deferredHandlingNeeded = false
|
|
|
|
|
|
- while runEpoll {
|
|
+ while !stopped {
|
|
let count = Int(epoll_wait(epollDescriptor, &pollingEvents, Int32(maximumNumberOfEvents), epollTimeout))
|
|
let count = Int(epoll_wait(epollDescriptor, &pollingEvents, Int32(maximumNumberOfEvents), epollTimeout))
|
|
|
|
|
|
if count == -1 {
|
|
if count == -1 {
|
|
|
@@ -164,6 +184,10 @@ public class IncomingSocketManager { |
|
deferredHandlingNeeded = process(deferredHandlers: &deferredHandlers)
|
|
deferredHandlingNeeded = process(deferredHandlers: &deferredHandlers)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
+
|
|
|
|
+ // cleanup after manager stopped
|
|
|
|
+ removeIdleSockets(removeAll: true)
|
|
|
|
+ close(epollDescriptor)
|
|
}
|
|
}
|
|
|
|
|
|
private func process(deferredHandlers: inout [Int32: IncomingSocketHandler]) -> Bool {
|
|
private func process(deferredHandlers: inout [Int32: IncomingSocketHandler]) -> Bool {
|
|
|
@@ -193,13 +217,15 @@ public class IncomingSocketManager { |
|
/// to have a lock around the access to the socketHandlers Dictionary. The other
|
|
/// to have a lock around the access to the socketHandlers Dictionary. The other
|
|
/// idea here is that if sockets aren't coming in, it doesn't matter too much if
|
|
/// idea here is that if sockets aren't coming in, it doesn't matter too much if
|
|
/// we leave a round some idle sockets.
|
|
/// we leave a round some idle sockets.
|
|
- private func removeIdleSockets() {
|
|
+ ///
|
|
|
|
+ /// - Parameter allSockets: flag indicating if the manager is shutting down, and we should cleanup all sockets, not just idle ones
|
|
|
|
+ private func removeIdleSockets(removeAll: Bool = false) {
|
|
let now = Date()
|
|
let now = Date()
|
|
- guard now.timeIntervalSince(keepAliveIdleLastTimeChecked) > keepAliveIdleCheckingInterval else { return }
|
|
+ guard removeAll || now.timeIntervalSince(keepAliveIdleLastTimeChecked) > keepAliveIdleCheckingInterval else { return }
|
|
|
|
|
|
let maxInterval = now.timeIntervalSinceReferenceDate
|
|
let maxInterval = now.timeIntervalSinceReferenceDate
|
|
for (fileDescriptor, handler) in socketHandlers {
|
|
for (fileDescriptor, handler) in socketHandlers {
|
|
- if handler.processor != nil && (handler.processor!.inProgress || maxInterval < handler.processor!.keepAliveUntil) {
|
|
+ if !removeAll && handler.processor != nil && (handler.processor!.inProgress || maxInterval < handler.processor!.keepAliveUntil) {
|
|
continue
|
|
continue
|
|
}
|
|
}
|
|
socketHandlers.removeValue(forKey: fileDescriptor)
|
|
socketHandlers.removeValue(forKey: fileDescriptor)
|
|
|
|


Monitor Live Chats
Student Name
Student Name
Student Name
Student Name
Student Name
Student Name
Student Name
Student Name
Student Name
Student Name
Student Name
Student Name
Three minutes ago
¡Hola!
Three minutes ago
Hello!
Two minutes ago
¿Cómo estás?


Search all our events >>
Pirate park
Bedford Town
Bibury trout farm
Login with your email or username
Login


1. General
1.1 This eFlow website is operated by Sanef ITS Operations Ireland Limited ("emovis operations Ireland") on behalf of Transport Infrastructure Ireland ("TII"). emovis operations Ireland and the TII fully respects your right to privacy, and will not collect any personal information about you on this website without your clear knowledge and permission. Any personal information which you volunteer to us will be treated strictly in accordance with the Data Protection Acts 1988 and 2003.
1.2 Please read the terms of this privacy statement carefully, as by visiting this website you will be deemed to have accepted the terms of this privacy statement.
2. Collection and use of personal information
2.1 We will collect no personally identifying information about you when you visit our website unless you choose to provide that information to us. The information we collect depends on what you do when visiting our site.
2.2 If you visit our site to browse, read or download we automatically collect and store your IP address, browser type and length of user sessions. We use this information to help us make our site more useful to visitors, to learn about the number of visitors to our site and the type of technology our visitors use. We do not track or record information about individuals on their visits. We may compile and report aggregate statistics about our users in terms of numbers, traffic patterns and related site information. Any such statistics will not include any personally identifying information.
2.3 You may choose to provide us with personal data (e.g. name, email and postal address) in correspondence to one of the addresses listed on our website. We use these details solely for the purpose of dealing with your query.
2.4 If you open an account or pay a toll on our website, we ask you to provide us with, amongst other things, your name, email address, contact telephone number, vehicle registration number and credit card, debit card or direct debit details. We use this data for the purposes of processing your toll payment and/or managing your tag account. We do not collect any more personal data than is necessary to fulfil these purposes.
3. Disclosure of Personal Data
3.1 We may disclose your personal data to our agents, contractors and service providers to the extent reasonably required for the purposes described above.
3.2 We may also share information about the way you conduct your Tag account with credit reference agencies.
4. Cookies
4.1 This website uses cookies, so a cookie may be placed in your internet browser. Cookies are small text files which provide us with information about how often someone visits our site, and what he/she does during those visits. Cookies do not themselves contain any personally identifying information but if you provide information to us, it may be linked to the data stored in the cookie.
4.2 If you do not want your browser to accept cookies, you can turn off the cookie acceptance option in your browser settings. Disabling cookie support may prevent this website from functioning properly and you may not be able to utilise fully all of its features and information.
For more information about the way this website uses cookies click here.
5. Security
5.1 For site security purposes and to ensure that this website remains available to all users, our computer system employs software programs to monitor network traffic in order to identify unauthorised attempts to upload or change information or otherwise cause damage. Unauthorised attempts to upload information or change information on our website are strictly prohibited and may be punishable by law.
5.2 Your personal data which you provide to us will be held on secure servers hosted by emovis operations Ireland. The nature of the internet is such that we cannot guarantee the security of any information you transmit to us online. However, we take all reasonable steps (including appropriate technical and organisational security measures) to protect your personal data.
6. Changes to this Privacy Statement
6.1 From time to time we may decide to change our privacy statement, but any changes will be posted on this page to keep you up to date with how we collect, use and disclose information. If at any time we decide to use personal data in a manner significantly different from that stated in this privacy statement, or otherwise disclosed to you at the time it was collected, we will notify you, and you will have the choice as to whether or not we use your information in the new manner.
7. Right of Access and Deletion of Data
7.1 You have the right, subject to certain exemptions, to obtain a copy of any personal data we hold about you and to correct any inaccuracies in such data. You also have the right, subject to certain conditions, to request the deletion of any personal data we hold about you. If you wish to avail of any of these rights, please write to us at: eFlow, Cape House, Westend Office Park, Dublin 15, marked for the attention of the "Data Protection Officer". Your request will be dealt with as soon as possible and will not take more than 40 days to process.
Cookie Policy
1. Purpose
The purpose of this policy is to provide visitors to the eFlow website with a clear understanding of how our website uses cookies and to explain how cookies can be managed by visitors to our site.
2. Scope
This policy is applicable to eflow.ie
3. Introduction
A cookie is a small text file that is placed on your computer by your web browser during your interaction with various websites. Cookies on the eFlow website consist of anonymous information about the user and are used by our website for various reasons including;
- to track a user’s session login so that each user can navigate securely and undisrupted across different web pages of our website;
- to balance the amount of incoming network traffic accessing services from eFlow web servers;
- to provide a reliable mechanism for our website to remember the state of the website or activity the user had taken in the past. This can include what selections and/or what pages were visited by the user in the past.
Some cookies on our website are “strictly” necessary for the services of the website to function whilst some are “not strictly” necessary but are required to provide a better customer experience and/or provide us with information for the purposes of future enhancement of the site. Other “third party” cookies are used for providing additional tools and gadgets on the site.
4.0 Cookie Types
Session cookies used for maintaining a users login credentials throughout a web session and/or for load-balancing are strictly necessary on our website in order for the site to function and perform at an acceptable service level. These cookies do not capture nor do they retain any personal information, as follows:
| Maintaining User Credentials |
We use session cookies to enable you to carry out some essential functions on our website, such as maintaining login details for each session as you navigate through various pages and avail of various services on our site such as; registering for an account, making a payment and more.
Session cookies also improve the performance of the website by minimising the need to repeatedly transfer information across the internet whilst providing a website service.
|
| Load Balancing |
We use a session cookie for load-balancing purposes to analyse and distribute incoming network traffic across our web servers. This balancing is necessary for providing an acceptable level of performance from our website services. |
Session cookies are not permanently stored on your device and expire when you terminate your browser session.
4.2 Cookies That Are Not Strictly Necessary
Persistent Cookies are used to collect statistical information from users on our website and to enhance customer experience on our site. These cookies are used by us to enhance our customers experience during their use of our site and to continuously improve our site, as follows:
Persistent cookies may reside on your device for a period of time but do not collect any personal information from any user.
| Google Analytics |
We use an analytics service from Google to enable us to recognise repeat visitors to our websites. By matching an anonymous, randomly generated identifier, we are able to record specific browsing information such as the source of your path to our site, the pages you have viewed, what options you have selected, and the path you have taken to navigate your way around our site. Having this information allows us to continually improve our sites. |
| Repeat Visitor Identification |
We use persistent cookies to identify repeat visitors to our reward card site. This cookie enhances user experience by preventing the repeated introduction splash-screen for repeat users of the service. |
4.3 Third-Party Cookies
We provide some additional features on our website in the form of tools and gadgets that we believe may be of interest to some of our customers, as follows:
| Tools and Gadgets |
To provide extra functionality for our users, we have in place some tools and gadgets on our websites. Tools such as RSS feeds are in place to show feeds from popular broadcasters which we feel may be of benefit to our users (e.g. Irish Times, weather forecasts etc.). Other tools provide quick links to popular websites (e.g. Amazon.com). |
Third-Party cookies are not controlled by us and we cannot access how they work. We advise you to check with these third-party organisations for more information about the control of these cookies.
Please also note that our website provides links to some of our business partners and to other organisations such as charities that we may have worked with throughout the year. By clicking on any of these links you may be brought to the website of that particular organisation. Each of these organisations may set their own cookies on your web browser which we have no control over.
5. Controlling Cookies
By using our website you agree that we can place cookies that are both strictly necessary and those that are not strictly necessary on your device.
If you wish to restrict or block the web browser cookies set on your device, you can do this through your web browser settings. The “Help” function within each browser explains how to change these settings, as follows:
Microsoft Internet Explorer
How to delete cookies in Microsoft Internet Explorer
Google Chrome
How to delete cookies in Google Chrome
Firefox
How to delete cookies in Firefox
Safari
How to delete cookies in Safari
For more comprehensive information on how to manage cookies on a wide range of browser types, including details on how to block cookies from your device please visit http://aboutcookies.org
Please note that blocking cookies may restrict many of the functions and services the website has to offer. If you share the use of a device your cookie settings will affect all users of that device.


 This saves people time, increases their productivity, helps them quickly complete their tasks/activities and helps them do so with minimal-to-no errors. The goal of this company is to build products that help people with busy schedules and active lifestyles achieve their goals efficiently through personalized automated processes. The company aims to build hardware and mechanical solutions that have never been built before by employing cutting-edge and latest engineering technologies.
Watch this video on the future of automation.
Feel free to sign up for more information.
You can also connect with me on Social Media.
Sign up to receive email updates on products.
You can expect to receive an email every 1-3 months.
These emails will include information about upcoming new products, their production status, market availability, release dates and estimated time frame of each milestone.
You can unsubscribe anytime by
To connect with me personally, follow me on Social Media.
Feel free to email Fauzia Lala if you have any questions, would like to connect, have suggestions, or would just like to say hello!


Click on the call button to "Call" Comcast Technical Support.
Speak now.
No speech was detected. You may need to adjust your microphone settings.
Click the "Allow" button above to enable your microphone.
Permission to use microphone was denied.
Permission to use microphone is blocked. To change, go to chrome://settings/contentExceptions#media-stream
Web Speech API is not supported by this browser. Upgrade to Chrome version 25 or later.


browsers overview
moteurs de rendus
cf The third browser war is over and it’s a bloodshed - Daniel Glazman - WEB2DAY 2016
| - | modern | standards | cross platform | speed | author |
|---|---|---|---|---|---|
| Gecko | OK | OK | OK | OK | Mozilla Foundation |
| WebKit | OK | OK | OK | OK | Apple |
| Blink | OK | OK | OK | OK | chromium (Google) |
| Edge | OK | OK | KO | OK | EdgeHTML (Microsoft) |
| Servo | OK | OK | OK | OK | servo.org (Mozilla Foundation) |
Trident moteur de IE4 à IE11 : stoppé.
Servo écrit en Rust est le petit nouveau. MultiThreadé et layout parallèle. Ultra performant. Va probablement beaucoup changer la donne sur mobile.
Meilleure vitesse mais surtout meilleure conso. (d’où la collaboration Mozilla / Samsung).
Opera a abandonné Presto et est passé sur Blink
Un process par tab, chaque process multithreadé + layout parallèle = gains x30 à x50.
C’est officiel, Microsoft Edge sera désormais basé sur Chromium (src)
Cela signifie que Microsoft va remplacer son moteur de rendu EdgeHTML et son moteur JavaScript Chackra par Blink et V8 de Chromium.
Microsoft prévoit encore de publier le nouveau Microsoft Edge sur toutes les versions prises en charge de Windows (c’est-à-dire Windows 7 et Windows 8), mais sans se limiter à son OS.
Le passage à Chromium prendra environ un an, selon Microsoft, et une préversion sera prête début 2019.
browsers bug trackers
The browser’s main functionality
The main function of a browser is to present the web resource you choose, by requesting it from the server and displaying it in the browser window. The resource is usually an HTML document, but may also be a PDF, image, or some other type of content. The location of the resource is specified by the user using a URI (Uniform Resource Identifier).
The way the browser interprets and displays HTML files is specified in the HTML and CSS specifications. These specifications are maintained by the W3C (World Wide Web Consortium) organization, which is the standards organization for the web. For years browsers conformed to only a part of the specifications and developed their own extensions. That caused serious compatibility issues for web authors. Today most of the browsers more or less conform to the specifications.
Browser user interfaces have a lot in common with each other. Among the common user interface elements are:
- Address bar for inserting a URI
- Back and forward buttons
- Bookmarking options
- Refresh and stop buttons for refreshing or stopping the loading of current documents
- Home button that takes you to your home page
The browser’s high level structure
- The user interface: this includes the address bar, back/forward button, bookmarking menu, etc. Every part of the browser display except the window where you see the requested page.
- The browser engine: marshals actions between the UI and the rendering engine.
- The rendering engine : responsible for displaying requested content. For example if the requested content is HTML, the rendering engine parses HTML and CSS, and displays the parsed content on the screen.
- Networking: for network calls such as HTTP requests, using different implementations for different platform behind a platform-independent interface.
- UI backend: used for drawing basic widgets like combo boxes and windows. This backend exposes a generic interface that is not platform specific. Underneath it uses operating system user interface methods.
- JavaScript interpreter. Used to parse and execute JavaScript code.
- Data storage. This is a persistence layer. The browser may need to save all sorts of data locally, such as cookies. Browsers also support storage mechanisms such as localStorage, IndexedDB, WebSQL and FileSystem.
How do browsers render a web page
- The DOM (Document Object Model) is formed from the HTML that is received from a server.
- Styles are loaded and parsed, forming the CSSOM (CSS Object Model).
- On top of DOM and CSSOM, a rendering tree is created, which is a set of objects to be rendered (Webkit calls each of those a “renderer” or “render object”, while in Gecko it’s a “frame”). Render tree reflects the DOM structure except for invisible elements (like the
<head>
tag or elements that have display:none; set). Each text string is represented in the rendering tree as a separate renderer. Each of the rendering objects contains its corresponding DOM object (or a text block) plus the calculated styles. In other words, the render tree describes the visual representation of a DOM. - For each render tree element, its coordinates are calculated, which is called “layout”. Browsers use a flow method which only required one pass to layout all the elements (tables require more than one pass).
- Finally, this gets actually displayed in a browser window, a process called “painting”.
When users interact with a page, or scripts modify it, some of the aforementioned operations have to be repeated, as the underlying page structure changes.
HTML Parsing
HTML cannot be parsed using the regular top down or bottom up parsers.
The reasons are:
- The forgiving nature of the language: the fact that browsers have traditional error tolerance to support well known cases of invalid HTML.
- The parsing process is reentrant. For other languages, the source doesn’t change during parsing, but in HTML, dynamic code (such as script elements containing document.write() calls) can add extra tokens, so the parsing process actually modifies the input.
- Speculative parsing: for scripts, css, images we will forward.
The algorithm consists of two stages: tokenization and tree construction.
Tokenization is the lexical analysis, parsing the input into tokens. Among HTML tokens are start tags, end tags, attribute names and attribute values.
The tokenizer recognizes the token, gives it to the tree constructor, and consumes the next character for recognizing the next token, and so on until the end of the input.
CSS Parsing
It just creates the CSSOM.
Render / Frame Tree
While the DOM tree is being constructed, the browser constructs another tree, the render tree. This tree is of visual elements in the order in which they will be displayed. It is the visual representation of the document. The purpose of this tree is to enable painting the contents in their correct order.
Firefox calls the elements in the render tree “frames”. WebKit uses the term renderer or render object.
A renderer knows how to lay out and paint itself and its children.
WebKit’s RenderObject class, the base class of the renderers, has the following definition:
class RenderObject{
virtual void layout();
virtual void paint(PaintInfo);
virtual void rect repaintRect();
Node* node; //the DOM node
RenderStyle* style; // the computed style
RenderLayer* containgLayer; //the containing z-index layer
}
Each renderer represents a rectangular area usually corresponding to a node’s CSS box, as described by the CSS2 spec. It includes geometric information like width, height and position.
The box type is affected by the “display” value of the style attribute that is relevant to the node (see the style computation section). Here is WebKit code for deciding what type of renderer should be created for a DOM node, according to the display attribute:
RenderObject* RenderObject::createObject(Node* node, RenderStyle* style)
{
Document* doc = node->document();
RenderArena* arena = doc->renderArena();
...
RenderObject* o = 0;
switch (style->display()) {
case NONE:
break;
case INLINE:
o = new (arena) RenderInline(node);
break;
case BLOCK:
o = new (arena) RenderBlock(node);
break;
case INLINE_BLOCK:
o = new (arena) RenderBlock(node);
break;
case LIST_ITEM:
o = new (arena) RenderListItem(node);
break;
...
}
return o;
}
Layout
When the renderer is created and added to the tree, it does not have a position and size. Calculating these values is called layout or reflow.
HTML uses a flow based layout model, meaning that most of the time it is possible to compute the geometry in a single pass. Elements later “in the flow” typically do not affect the geometry of elements that are earlier “in the flow”, so layout can proceed left-to-right, top-to-bottom through the document. There are exceptions: for example, HTML tables may require more than one pass.
The coordinate system is relative to the root frame. Top and left coordinates are used.
Layout is a recursive process. It begins at the root renderer, which corresponds to the <html>
element of the HTML document. Layout continues recursively through some or all of the frame hierarchy, computing geometric information for each renderer that requires it.
The position of the root renderer is 0,0 and its dimensions are the viewport–the visible part of the browser window.
All renderers have a “layout” or “reflow” method, each renderer invokes the layout method of its children that need layout.
Dirty bit system
In order not to do a full layout for every small change, browsers use a “dirty bit” system. A renderer that is changed or added marks itself and its children as “dirty”: needing layout.
There are two flags: “dirty”, and “children are dirty” which means that although the renderer itself may be OK, it has at least one child that needs a layout.
The layout algorithm
- Parent renderer determines its own width.
- Parent goes over children and:
- Place the child renderer (sets its x and y).
- Calls child layout if needed–they are dirty or we are in a global layout, or for some other reason–which calculates the child’s height.
- Parent uses children’s accumulative heights and the heights of margins and padding to set its own height–this will be used by the parent renderer’s parent.
- Sets its dirty bit to false.
Paint
In the painting stage, the render tree is traversed and the renderer’s “paint()” method is called to display content on the screen. Painting uses the UI infrastructure component.
Repaint
When changing element styles which don’t affect the element’s position on a page (such as background-color, border-color, visibility), the browser just repaints the element again with the new styles applied (that means a “repaint” or “restyle” is happening).
Reflow
When the changes affect document contents or structure, or element position, a reflow (or relayout) happens. These changes are usually triggered by:
- DOM manipulation (element addition, deletion, altering, or changing element order);
- Contents changes, including text changes in form fields;
- Calculation or altering of CSS properties;
- Adding or removing style sheets;
- Changing the “class” attribute;
- Browser window manipulation (resizing, scrolling);
- Pseudo-class activation (:hover).
How browsers optimize rendering
Browsers are doing their best to restrict repaint/reflow to the area that covers the changed elements only. For example, a size change in an absolute/fixed positioned element only affects the element itself and its descendants, whereas a similar change in a statically positioned element triggers reflow for all the subsequent elements.
Another optimization technique is that while running pieces of JavaScript code, browsers cache the changes, and apply them in a single pass after the code was run. For example, this piece of code will only trigger one reflow and repaint:
// only 1 reflow and repaint will actually happen
var $body = $('body');
$body.css('padding', '1px'); // reflow, repaint
$body.css('color', 'red'); // repaint
$body.css('margin', '2px'); // reflow, repaint
However, as mentioned above, accessing an element property triggers a forced reflow. This will happen if we add an extra line that reads an element property to the previous block:
var $body = $('body');
$body.css('padding', '1px');
$body.css('padding'); // reading a property, a forced reflow
$body.css('color', 'red');
$body.css('margin', '2px');
As a result, we get 2 reflows instead of one. Because of this, you should group reading element properties together to optimize performance (see a more detailed example on JSBin).
There are situations when you have to trigger a forced reflow. Example: we have to apply the same property (“margin-left” for example) to the same element twice. Initially, it should be set to 100px without animation, and then it has to be animated with transition to a value of 50px. You can study this example on JSBin right now, but I’ll describe it here in more detail.
We start by creating a CSS class with a transition:
.has-transition {
-webkit-transition: margin-left 1s ease-out;
-moz-transition: margin-left 1s ease-out;
-o-transition: margin-left 1s ease-out;
transition: margin-left 1s ease-out;
}
Then proceed with the implementation:
// our element that has a "has-transition" class by default
var $targetElem = $('#targetElemId');
// remove the transition class
$targetElem.removeClass('has-transition');
// change the property expecting the transition to be off, as the class is not there
// anymore
$targetElem.css('margin-left', 100);
// put the transition class back
$targetElem.addClass('has-transition');
// change the property
$targetElem.css('margin-left', 50);
This implementation, however, does not work as expected. The changes are cached and applied only at the end of the code block. What we need is a forced reflow, which we can achieve by making the following changes:
// remove the transition class
$(this).removeClass('has-transition');
// change the property
$(this).css('margin-left', 100);
// trigger a forced reflow, so that changes in a class/property get applied immediately
$(this)[0].offsetHeight; // an example, other properties would work, too
// put the transition class back
$(this).addClass('has-transition');
// change the property
$(this).css('margin-left', 50);
Now this works as expected.
Practical advice on optimization
Summarizing the available information, I could recommend the following:
- Create valid HTML and CSS
- Do not forget to specify the document encoding
- Styles should be included into
<head>
- Scripts appended to the end of the
<body>
tag. Think about async and defer attribute. - Try to simplify and optimize CSS selectors (this optimization is almost universally ignored by developers who mostly use CSS preprocessors). Keep nesting levels at a minimum. This is how CSS selectors rank according to their performance (starting from the fastest ones):
- Identificator:
#id
- Class:
.class
- Tag:
<div>
- Adjacent sibling selector:
a + i
- Parent selector:
ul > li
- Universal selector:
*
- Attribute selector:
input[type="text"]
- Pseudoclasses and pseudoelements:
a:hover
You should remember that browsers process selectors from right to left, that’s why the rightmost selector should be the fastest one — either#id
or.class
:div * {...} // bad
.list li {...} // bad
.list-item {...} // good
#list .list-item {...} // good
- Identificator:
- In your scripts, minimize DOM manipulation whenever possible. Cache everything, including properties and objects (if they are to be reused). It’s better to work with an “offline” element when performing complicated manipulations (an “offline” element is one that is disconnected from DOM and only stored in memory), and append it to DOM afterwards.
- To change element’s styles, modifying the “class” attribute is one of the most performant ways. The deeper in the DOM tree you perform this change, the better (also because this helps decouple logic from presentation).
- Animate only absolute/fixed positioned elements if you can.
- It is a good idea to disable complicated
:hover
animations while scrolling (e.g. by adding an extra “no-hover” class to<body>
).


We were unable to invite this user.
User information
First name
Last name
Email address
Role
Send invite
Cancel


2018-04-07 Witness Tool Update: How Many Blocks Have You Produced in the Last 24 Hours? witness-category
2018-03-30 SteemTools Update: Adding Account Witness Data, Option to Save Key and Bug Fixes utopian-io
2018-02-24 Turtle Graphics Programming Update: Adding text, jump, dot, fontsize, download as png utopian-io
2018-02-19 CoinTools Update: Cryptocurrency Converter Calculator, Support Coin Symbols and Add More Localization utopian-io


- Kaspersky Internet Security
- Norton Internet Security
- ZoneAlarm Internet Security Suite
- McAfee Internet Security Suite
- Require lots of system resources.
- Slows down a lot PC.
- Not comfortable configuration.
- Not a good compromise between advanced options and non-technical user.
These two packets work much faster on my PC (AthlonXP 2800 Barton, 512 MB RAM) than all-in-one packets. Also they provide more configuration abilities that allow me to have most reasonable for me settings. Also there's very good security value within these two programs see:
The only valuable thing I'm missing is an Anti-Spam system. So I'm already waiting for free antispam program from agnitum. They were writing about it in Agnitum Directions (31 October, 2006). Here's what they say:
We have been asked by many of our users for a powerful but easy-to-use utility to fight spam. We all know how tedious it is to dig through tons of spam to find the email you actually want to read. So, to help you fight spam, we are developing a new product called Agnitum Spam Terrier.But anyway I'm not happy enough with client-side antispam because of I get all spam in my mail client and should at least have a look at them for not to lose some important letter (that Anti-Spam system may wrongly determine as spam).


Netanyahu charged in graft cases; becomes first sitting PM to be indicted
The indictment does not require Netanyahu to resign but is expected to raise pressure on him to step down
by AP/PTIIsrael's attorney general on Thursday formally charged Prime Minister Benjamin Netanyahu in a series of corruption cases, throwing the country's paralyzed political system into further disarray and threatening the long-time leader's grip on power.
Attorney General Avichai Mandelblit charged Netanyahu with fraud, breach of trust and accepting bribes in three different scandals. It is the first time a sitting Israeli prime minister has been charged with a crime. Mandelblit was set to issue a formal statement later Thursday.
Allegations against Netanyahu include suspicions he accepted hundreds of thousands of dollars of champagne and cigars from billionaire friends, offered to trade favors with a newspaper publisher and used his influence to help a wealthy telecom magnate in exchange for favorable coverage on a popular news site.
The indictment does not require Netanyahu to resign but is expected to raise pressure on him to step down.
Netanyahu has called the allegations part of a witch hunt, lashing out against the media, police, prosecutors and the justice system. Netanyahu was scheduled to issue a statement later Thursday.


My First Website
Music
I am a musician. I have taught my self to play various instruments. Which include:
Piano
Guitar
Alto Saxophone
Tenor Saxophone
Baritone Saxophone
Drums (Drum set)
and Bass Guitar
Business
Philosophy
Religion
Physics


WiiNode is a library for connecting your WiiMote to PlotDevice. No actual Wii is needed, just the remote.
| wiinode.zip (24KB) Last updated for NodeBox 1.9.4 Licensed under the GPL Author: Frederik De Bleser |
OSCulator makes the connection with the WiiMote
possible. The necessary configuration settings are in the wiidraw.zip
file under
settings.oscd
.
The program needs to be running in the background, and communicates over OSC.
Getting your WiiMote to work with the program, for me, meant pushing the buttons ‘1’ and ‘2’, or alternatively, the red SYNC button (under the battery cover), a few times. Once you get a battery reading, you should be fine.
Put the web library folder in the same folder as your script so PlotDevice can find the library. You can also put it in ~/Library/Application Support/PlotDevice/.
wiinode = ximport("wiinode")
Outside of PlotDevice you can also just do import wiinode.
In your animation, initialize the WiiMote object. Then, in each frame, call the update method:
def setup(): global wm wm = wiinode.WiiMote()def draw(): global wm wm.update() print wm.yaw
To get a good overview of all the values, check out wiinode_example3.py
, which
visualizes all available WiiMote attributes.
Rotation
The WiiMote returns roll, pitch and yaw. See the Wikipedia article on flight dynamics for more information.
See the wiinode_example1.py
for a game that uses the roll value.
wm.pitch # The absolute pitch valuewm.roll # The absolute roll valuewm.yaw # The absolute yaw value
Acceleration
The WiiMote returns acceleration in both x, y and z positions. This is not the remote’s absolute position in space. You need an infrared sender for that.
wm.x # The horizontal (left-right) accelerationwm.y # The forward accelerationwm.z # The vertical (up-down) acceleration
Buttons
The WiiMote’s A and B buttons can be monitored as well.
wm.a # True if the A button is pressedwm.b # True if the B button is pressed


Static files are placed here: path/to/SVCure/svcure/static/public/
The following files must be placed into the above static directory:
BED: tab-delimited with 4 columns: chromosome, variant start, variant end, variant type
You can put anything in the 4th column if variant is unknown but ensure it exists
This column is used to label variants in igv.js and is not case sensitive
BAM/CRAM: May use BAM or CRAM but must have their respective indices named as so: your_name.bam and your_name.bam.bai
Reference FASTA: may use whichever extension (.fa, .fasta, etc.) but the index must be named the same way as described for .bam/.cram format; i.e., your_name.fa and your_name.fa.fai
Single Sample Loading
Use when you have only one or a few samples to annotate
Fill in the form with the given values:
1st Column: genome name of choice
2nd Column: alignment file in bam or cram format
3rd Column: alignment file index, named the same as its respective alignment file but with an added .bai or .crai
4th Column: reference fasta file with suffix of choice
5th Column: reference build, example: hg18, hg19, hg38, mm10, etc.
6th Column: bed file containing variant call with 4 columns (see above)
7th Column: technology pertaining to the alignment file
Once completely filled-in, click the “save” button below the form
Depending on the number of variants in the bed file, the load operation after clicking “save” may be instantaneous or take a few minutes
Batch (Multi-Sample) Loading
Use when you have several samples to annotate
An example file is located in the SVCure directory called: load_annotations.csv
Comma-separated format, 7 total columns, and no header
Each new line in the file is based on the technology (7th column) pertaining to the alignment (bam/cram) files for a genome
Please do not place multiple technologies in the same line
1st Column: genome name of choice
2nd Column: alignment file in bam or cram format
3rd Column: alignment file index, named the same as its respective alignment file but with an added .bai or .crai
4th Column: reference fasta file with suffix of choice
5th Column: reference build, example: hg18, hg19, hg38, mm10, etc.
6th Column: bed file containing variant call with 4 columns (see above)
7th Column: technology pertaining to the alignment file
Fill in .csv file as above, click the upload button, select filled-in .csv file, click “save” button below upload button
After clicking the “save” button, the loading operation may take several minutes if you have several samples with several technologies and thousands of variants per technology


Test!
Testing scroll bars and interactive div resizing
It Works: adding scroll bar into single div In the works: resizing div with table inside containing horizontal scroll resizing widget added, seems to work only on certain width percentages
A
B
C
D


UnbindMenuEvent()
Syntax
UnbindMenuEvent(#Menu, MenuItem, @Callback())Description
Unbind a menu event from a callback. If no matching event callback is found, this command has no effect.
Parameters
#Menu The menu to unbind the event. MenuItem The menu item within the menu to unbind the event. @Callback() The callback procedure to unbind.
Return value
None.
Example
Procedure TestHandler() Debug "Test menu event" EndProcedure Procedure QuitHandler() Debug "Quit menu event" End EndProcedure OpenWindow(0, 100, 100, 200, 50, "Click test", #PB_Window_SystemMenu) CreateMenu(0, WindowID(0)) MenuTitle("File") MenuItem(0, "Test") MenuItem(1, "Quit") BindMenuEvent(0, 0, @TestHandler()) BindMenuEvent(0, 1, @QuitHandler()) UnbindMenuEvent(0, 1, @QuitHandler()) ; Unbind the quit event Repeat Event = WaitWindowEvent() Until Event = #PB_Event_CloseWindow
See Also
BindEvent(), BindGadgetEvent(), BindMenuEvent(), WindowEvent(), WaitWindowEvent()
Supported OS
All


Auto Mart
Search
Your Showroom
Update your listing
Update your price
Enter amount (in NGN)
*
Update Ad


Thank you
Your submission and any supporting files have been delivered to the Amy Winehouse Foundation.


Context
Game Jam entry for LudamDare 46 Game Jam
Role
Unity C# Programmer
Jam
Chris Wong
Tamiko Tadeo
Kenny Cheung
Danielle Ragas
Nancy Chen
This is fine is a Unity game built by a team of artists and programmers for the Ludamdare 46 Game Jam. The jam lasted for 72 hours and 4959 games were submitted. The theme was “Keep It Alive”.
Please come and try our game: This Is Fine
Our game comes from a meme "This Is Fine" by KC Green’s in his 2013 webcomic "On Fire". We struggled to design game mechanics that best fit the theme of the meme. At the end, countless debate on the mechanics resulted in a set of
mechanics that all of us are satisfied with.

- Players has the press the “Wait” button to advance time, which allows the fire to spread to nearby source, and allow the dog to move.
- Players will have to place variety a of furnitures in different shapes onto the grid to spread and maintain the fire, or eventually it goes out on its own.
- The dog can be lured by a stick placed in a horizontal or vertical place within 10 steps.
In this project, my main contribution is the design of the code structure and to implement the grid system for the game. Some of the requirements were:
- Players will be abl to drag elements onto a grid
- Elements mostly comes in different shapes and occupy multiple nodes. For example, there was a L-shaped sofa that takes up 4 nodes
- When players pick up an element, the element will follow the mouse with the most top-left node as the anchor
Originally, the team has decided an alternative approach to implement the grid.
We were going to build it with a 2D Array of GameObjects to contain the current elements on the grid. Initially, we think this way makes the most sense, and was our first instinct when we think of a grid.
However, considering one of the amazing L-shaped bed another programmer has suggested in sketch, I quickly realized the 2D Array of GameObject will not be the most efficient way to implement it.
The problem is that most of our object are going to take up multiple nodes on the grid. To explain this, let’s use the beloved L-Shape Bed as an example:
The bed is occupying nodes [0,0], [1,0] and [0,1]. In this case, with our old approach, all 3 nodes on the 2D Array would have a piece of the bed game object, which is not efficient and would not work with our mechanics.
Another similar approach is to allow one of the node contains the entire object, and the object itself keeps references to the 3 nodes it occupy. Although I did not suggest this approach at the end, some of the aspect were taken into our
final structure. The problem with this approach is that there is no need to have a 2D Array structure anymore because the object itself will still have to keep references on its occupying nodes.
At the end, I suggested to simply storing the game objects in a 1-dimentional array, and have each object keep track of it’s root node (most top-left node) and subsequent node by displacement from the root node.
One of the advantage for this approach is we no longer need to loop through a 2D array to check the objects, which possibly resulted in performance increases.
Another advantage comes from the way subsequent nodes were kept track of by the displacement from the root node. The displacement allows us to quickly process and understand where the child nodes are even as the object is moving around. For
example, the L-Shaped Bed has the root node at [0,0], and the displacement of its subsequent nodes are [1,0] and [0,1]. When it’s root position is moved [5,5], with the displacement instead of hard coded location, we can quickly obtain the
child node positions at [6,5] and [5,6] by just adding the displacement to the current root position.
To root out the potential problem and explain better to the team, I quickly built a prototype to demonstrate. I have also considered the other applications of the grid such as prevention of user dragging an element to a node occupied.
My approach was accepted and adopted into the final game.
I have gathered experience and had fun on working with other programmers. The grid is largely depended on by the other features. For example, when the objects are moving, they have to know if the next node is occupied by any objects; when
the
fire is spreading, it needs to know the currently occupying object in the near nodes. When the need of a new function is suggested, new methods were written to satisfy the needs. Gradually, the grid system becomes something closer to an
API, an isolated module that can be tested individually.
Other than the grid, I am also responsible to import most of the sprite sheets and turn them into animations and animation controllers. Additionally, I have worked on the inventory system, helping with the drag and drop raycast collision problem.
When we are in the phase of making levels, I tasked myself to build the most clever level I can. I started by thinking how the difficult levels are like in many puzzles games I have played. Some of them uses tight constraints to limit
player’s choice and requires dynamics between game functions. I started by placing objects in a compact grid of 3 X 3, but soon realize the lowest size of grid that my level in mind needs is 5 X 5. At the end, I successfully built a level
that I am proud of. Please play my level #8.
We received 116th overall, not as good as our previous submission to LD45 Finished Racoon Bikini Game, but the process is extremely fun which made the result not as important. We will definitely join the next jam as well.
Please come and try our game: This Is Fine


Amazing Quora
Focus mode
Pick what to hide
Questions for You
Advertisements
Discover New People
Discover New Topics
CopyRight © 2018. Sharang Malhotra. All rights reserved.


(%_logo_%)
(%_tagline_%)
(%_link1_text_%)
(%_link2_text_%)
(%_link3_text_%)
(%_link4_text_%)
(%_link6_text_%)
(%_portfolio_grid_%)


Georginio Wijnaldum takes stand against racism with goal celebration
Holland's hat-trick hero and stand-in captain Georginio Wijnaldum made it a point to make his views known about racism in football after opening the scoring in a 5-0 Group C Euro 2020 qualifier against Estonia yesterday morning (Singapore time).
Wijnaldum, who stood alongside teammate Frenkie de Jong in the celebration of his first goal, held their arms out and pointed to the colours of their skin.
It follows allegations of racist abuse aimed at Dutch second-tier player Ahmad Mendes Moreira during a game between his side SBV Excelsior and Den Bosch last weekend.
Wijnaldum had spoken about the incident in the build-up to the match and tweeted an anti-racism message after the fixture.
Dutch coach Ronald Koeman welcomed the gesture, saying: "Gini just said something about it in the dressing room during our closing words with each other.
"He said he feels so happy with this Dutch team, where this problem (of racism) does not occur. It is one team. It's nice to see that."
Koeman had plenty of reasons to be happy yesterday with debutants Calvin Stengs, 20, and Myron Boadu, 18, grabbing two assists and a goal respectively. Defender Nathan Ake, 24, scored Holland's other goal.
"It would be very strange if everything was clear against Estonia," Koeman told Dutch broadcaster NOS.
"We still have six months. We have a lot of young players who will be half a year older. It will be a fight."
Koeman added that next March's international window would heavily influence the make-up of his Euro 2020 squad. - REUTERS


You can easily embed MapStore2 in your website, and load your UI and configuration dinamically!
Use the MapStore2 JavaScript API to add a MapStore2 map and tools to your page.
MapStore2.create('container', { plugins: ["Map"] });
Look at the full code of this example and the JS API documentation for more information.
Toggle Weather Layer (if present)


Add new project
Field 'Name' is required
Field 'Description' is required
Field 'Description' must be at least 15 characters
Field 'Team Id' is required


Home
Portfolios
Photo
About Me
Home
Portfolios
Photos
About me
Some of my work
Home
Portfolios
Photos
About me
copyright© Yuqing Xia


| I l@ve RuBoard |
7.8 Running GUI Code Three WaysNow that we've built a handful of similar demo launcher programs, let's write a few top-level scripts to combine them. Because the demos were coded as both reusable classes and scripts, they can be deployed as attached frame components, run in their own top-level windows, and launched as standalone programs. All three options illustrate code reuse in action. 7.8.1 Attaching FramesTo illustrate hierarchical GUI composition on a grander scale than we've seen so far, Example 7-32 arranges to show all four of the dialog launcher bar scripts of this chapter in a single frame. It reuses Example 7-9, Example 7-22, Example 7-25, and Example 7-30. Example 7-32. PP2E\Gui\Tour\demoAll-frm.py##################################################### # 4 demo class components (subframes) on one window; # there are 5 Quitter buttons on this one window too; # guis can be reused as frames, windows, processes; ##################################################### from Tkinter import * from quitter import Quitter demoModules = ['demoDlg', 'demoCheck', 'demoRadio', 'demoScale'] parts = [] def addComponents(root): for demo in demoModules: module = __import__(demo) # import by name string part = module.Demo(root) # attach an instance part.config(bd=2, relief=GROOVE) part.pack(side=LEFT, fill=BOTH) parts.append(part) # change list in-place def dumpState(): for part in parts: # run demo report if any print part.__module__ + ':', if hasattr(part, 'report'): part.report() else: print 'none' root = Tk() # default toplevel window Label(root, text='Multiple Frame demo', bg='white').pack() Button(root, text='States', command=dumpState).pack(fill=X) Quitter(root).pack(expand=YES, fill=X) addComponents(root) mainloop() Because all four demo launcher bars are coded to attach themselves to parent container widgets, this is easier than you might think: simply pass the same parent widget (here, the root window) to all four demo constructor calls, and pack and configure the demo objects as desired. Figure 7-32 shows this script's graphical result -- a single window embedding instances of all four of the dialog demo launcher demos we saw earlier. Figure 7-32. demoAll_frm: nested subframesNaturally, this example is artificial, but it illustrates the power of composition when applied to building larger GUI displays. If you pretend that each of the four attached demo objects was something more useful, like a text editor, calculator, or clock, you'll better appreciate the point of this example. Besides demo object frames, this composite window also contains no less than five instances of the Quitter button we wrote earlier (any one of which can end the GUI), and a States button to dump the current values of all the embedded demo objects at once (it calls each object's report method, if it has one). Here is a sample of the sort of output that shows up in the stdout stream after interacting with widgets on this display; States output is in bold: C:\...\PP2E\Gui\Tour>python demoAll_frm.py in onMove 0 in onMove 0 demoDlg: none demoCheck: 0 0 0 0 0 demoRadio: demoScale: 0 you pressed Input result: 1.234 demoDlg: none demoCheck: 1 0 1 1 0 demoRadio: Input demoScale: 0 you pressed Query result: yes in onMove 1 in onMove 2 You picked 2 C:/PP2ndEd/examples/PP2E/Gui/Tour/demoAll_frm.py demoDlg: none demoCheck: 1 0 1 1 0 demoRadio: Query demoScale: 2 The only substantially tricky part of this script is its use of Python's built-in __import__ function to import a module by a name string. Look at the following two lines from the script's addComponents function: module = __import__(demo) # import module by name string part = module.Demo(root) # attach an instance of its Demo This is equivalent to saying something like this: import 'demoDlg' part = 'demoDlg'.Demo(root) except that this is not legal Python syntax -- the module name in import statements must be a Python variable, not a string. To be generic, addComponents steps through a list of name strings, and relies on __import__ to import and return the module identified by each string. It's as though all of these statements were run: import demoDlg, demoRadio, demoCheck, demoScale part = demoDlg.Demo(root) part = demoRadio.Demo(root) part = demoCheck.Demo(root) part = demoScale.Demo(root) But because the script uses a list of name strings, it's easier to change the set of demos embedded -- simply change the list, not lines of executable code. Moreover, such data-driven code tends to be more compact, less redundant, and easier to debug and maintain. Incidentally, modules can also be imported from name strings by dynamically constructing and running import statements like this: for demo in demoModules: exec 'from %s import Demo' % demo # make and run a from part = Demo(root) # or eval('Demo')(window) The exec statement compiles and runs a Python statement string (here, a from to load a module's Demo class); it works here as if the statement string were pasted into the source code where the exec statement appears. Because it supports any sort of Python statement, this technique is more general than the __import__ call, but, it can also be slower, since it must parse code strings before running them.[2] But that slowness may not matter in a GUI; users tend to be slower than parsers.
As we saw in Chapter 6, attaching nested frames like this is really just one way to reuse GUI code structured as classes. It's just as easy to customize such interfaces by subclassing, rather than embedding. Here, though, we're more interested in deploying an existing widget package, rather than changing it; the next two sections show two other ways to present such packages to users. 7.8.2 Independent WindowsOnce you have a set of component classes, any parent will work -- both frames, and brand new top-level windows. Example 7-33 attaches instances of all four demo bar objects to their own Toplevel windows, not the same Frame. Example 7-33. PP2E\Gui\Tour\demoAll-win.py#################################################### # 4 demo classes in independent top-level windows; # not processes: when one is quit all others go away # because all windows run in the same process here #################################################### from Tkinter import * demoModules = ['demoDlg', 'demoRadio', 'demoCheck', 'demoScale'] demoObjects = [] for demo in demoModules: module = __import__(demo) # import by name string window = Toplevel() # make a new window demo = module.Demo(window) # parent is the new window demoObjects.append(demo) def allstates(): for obj in demoObjects: if hasattr(obj, 'report'): print obj.__module__, obj.report() Label(text='Multiple Toplevel window demo', bg='white').pack() Button(text='States', command=allstates).pack(fill=X) mainloop() We met the Toplevel class earlier; every instance generates a new window on your screen. The net result is captured in Figure 7-33 -- each demo runs in an independent window of its own, instead of being packed together in a single display. Figure 7-33. demoAll_win: new Toplevel windowsThe main root window of this program appears in the lower left of this screen shot; it provides a States button that runs the report method of each of the demo objects, producing this sort of stdout text: C:\...\PP2E\Gui\Tour>python demoAll_win.py in onMove 0 in onMove 0 in onMove 1 you pressed Open result: C:/PP2ndEd/examples/PP2E/Gui/Tour/demoAll_win.txt demoRadio Open demoCheck 1 1 0 0 0 demoScale 1 7.8.3 Running ProgramsFinally, as we learned earlier in this chapter, Toplevel windows function independently, but they are not really independent programs. Quitting any of the windows created by Example 7-33 quits them all, because all run in the same program process. That's okay in some applications, but not all. To go truly independent, Example 7-34 spawns each of the four demo launchers as independent programs, using the launchmodes module we wrote at the end of Chapter 3. This only works because the demos were written as both importable classes and runnable scripts -- launching them here makes all their names __main__ when run. Example 7-34. PP2E\Gui\Tour\demoAll-prg.py####################################################### # 4 demo classes run as independent program processes; # if one window is quit now, the others will live on; # there is no simple way to run all report calls here, # and some launch schemes drop child program stdout; ####################################################### from Tkinter import * demoModules = ['demoDlg', 'demoRadio', 'demoCheck', 'demoScale'] from PP2E.launchmodes import PortableLauncher for demo in demoModules: # see Parallel System Tools PortableLauncher(demo, demo+'.py')() # start as top-level programs Label(text='Multiple program demo', bg='white').pack() mainloop() As Figure 7-34 shows, the display generated by this script is similar to the prior one -- all four demos come up in windows of their own. This time, though, these are really independent programs: if any one of the five windows here is quit, the others live on. Figure 7-34. demoAll_prg: independent programs<IP_ADDRESS> Cross-program communicationSpawning GUIs as programs is the ultimate in code independence, but makes the lines of communication between components more complex. For instance, because the demos run as programs here, there is no easy way to run all their report methods from the launching script's window pictured in the middle of Figure 7-34. In fact, the States button is gone this time, and we only get PortableLauncher messages in stdout as the demos start up: C:\...\PP2E\Gui\Tour>python demoAll_prg.py demoDlg demoRadio demoCheck demoScale On some platforms, messages printed by the demo programs (including their own State buttons) may show up the original console window where this script is launched; on Windows, the os.spawnv call used to start programs in launchmodes completely disconnects the child program's stdout stream from its parent. Regardless, there is no way to call all demos' report methods at once -- they are spawned programs in distinct address spaces, not imported modules. Of course, we could trigger report methods in the spawned programs with some of the IPC mechanisms we met in Chapter 3. For instance:
Given their event-driven nature, GUI-based programs may need to be augmented with threads or timer-event callbacks to periodically check for such incoming messages on pipes, fifos, or sockets (e.g., see the after method call described near the end of the next chapter). But since this is all well beyond the scope of these simple demo programs, I'll leave such cross-program extensions up to more parallel-minded readers. <IP_ADDRESS> Coding for reusabilityA postscript: I coded all the demo launcher bars deployed by the last three examples to demonstrate all the different ways that their widgets can be used. They were not developed with general-purpose reusability in mind; in fact, they're not really useful outside the context of introducing widgets in this book. That was by design; most Tkinter widgets are easy to use once you learn their interfaces, and Tkinter already provides lots of configuration flexibility by itself. But if I had in mind to code checkboxes and radiobutton classes to be reused as general library components, they would have to be structured differently:
Example 7-35 shows one way to code check and radiobutton bars as library components. It encapsulates the notion of associating Tkinter variables, and imposes a common usage mode on callers to keep the interface simple -- state fetches, instead of press callbacks. Example 7-35. PP2E\Gui\Tour\buttonbars.py# check and radio button bar classes for apps that fetch state later; # pass a list of options, call state(), variable details automated from Tkinter import * class Checkbar(Frame): def __init__(self, parent=None, picks=[], side=LEFT, anchor=W): Frame.__init__(self, parent) self.vars = [] for pick in picks: var = IntVar() chk = Checkbutton(self, text=pick, variable=var) chk.pack(side=side, anchor=anchor, expand=YES) self.vars.append(var) def state(self): return map((lambda var: var.get()), self.vars) class Radiobar(Frame): def __init__(self, parent=None, picks=[], side=LEFT, anchor=W): Frame.__init__(self, parent) self.var = StringVar() for pick in picks: rad = Radiobutton(self, text=pick, value=pick, variable=self.var) rad.pack(side=side, anchor=anchor, expand=YES) def state(self): return self.var.get() if __name__ == '__main__': root = Tk() lng = Checkbar(root, ['Python', 'C#', 'Java', 'C++']) gui = Radiobar(root, ['win', 'x11', 'mac'], side=TOP, anchor=NW) tgl = Checkbar(root, ['All']) gui.pack(side=LEFT, fill=Y) lng.pack(side=TOP, fill=X) tgl.pack(side=LEFT) lng.config(relief=GROOVE, bd=2) gui.config(relief=RIDGE, bd=2) from quitter import Quitter def allstates(): print gui.state(), lng.state(), tgl.state() Quitter(root).pack(side=RIGHT) Button(root, text='Peek', command=allstates).pack(side=RIGHT) root.mainloop() To reuse these classes in your scripts, import and call with a list of the options you want to appear in a bar of checkboxes or radiobuttons. This module's self-test code at the bottom of the file gives further usage details. It generates Figure 7-35 when this file is run as a program instead of imported -- a top-level window that embeds two Checkbars, one Radiobar, a Quitter button to exit, and a Peek button to show bar states. Figure 7-35. buttonbars self-test windowHere's the stdout text you get after pressing Peek -- the results of these classes' state methods: x11 [1, 0, 1, 1] [0] win [1, 0, 0, 1] [1] The two classes in this module demonstrate how easy it is to wrap Tkinter interfaces to make them easier to use -- they completely abstract away many of the tricky parts of radiobutton and checkbox bars. For instance, you can forget about linked variable details completely if you use such higher-level classes instead; simply make objects with option lists and call their state methods later. If you follow this path to its conclusion, you might just wind up with a higher-level widget library on the order of the PMW package mentioned in Chapter 6. On the other hand, these classes are still not universally applicable; if you need to run actions when these buttons are pressed, for instance, you'll need to use other high-level interfaces. Luckily, Python/Tkinter already provides plenty. Later in this book, we'll again use the widget combination and reuse techniques introduced in this section to construct larger GUIs. For now, this first widget tour chapter is about to make one last stop -- the photo shop. |
| I l@ve RuBoard |


USD/CAD: Sellers cheer WTI strength, eyes on Canadian Retail Sales/trade headlines
by Anil Panchal- USD/CAD extends previous declines amid WTI strength, ignores a lack of trade news.
- Canadian Retail Sales, US PMI and consumer sentiment data occupy economic calendar.
- Trade/political developments surrounding the US and China will also be the key.
USD/CAD remains under pressure following its pullback from six-week-high. The quote takes rounds to 1.3280 by the press time of the Asian session on Friday.
While pessimism concerning the phase one trade deal between the United States (US) and China has been downplaying trade-exposed currencies off-late, the Loonie pair recently benefited from the oil prices uptick to the two month high. The WTI declines could be attributed to geopolitical tension in Iran and a likely extension of global production cuts. Recent news from Global Times that China has just revised up its 2018 Gross Domestic Product (GDP) by 2.1%.
Also exerting downside pressure on the prices was hawkish comments from the Bank of Canada (BOC) Governor Stephen Poloz. "Poloz said the economy is in a good place and described monetary policy as "about right." However, the Bank continues to monitor for signs of spillovers and we do not think they will hesitate to act should the outlook deteriorate further," says TD Securities.
The US-China trade stalemate continues with the latest news suggesting the US may delay December 15 tariff high while Beijing still has the Trump administration diplomats on their invitation list. Further, the US Navy reported two ships rounded in the South China Sea, which in turn could push the dragon nation towards other rounds of warnings. The previous one was targeting the US House of Representative’s passage of Hong Kong Bill.
September month Canadian Retail Sales will be the first to entertain momentum traders during the US session whereas the US Markit Manufacturing and Services Purchasing Managers Index (PMI), followed by Michigan Consumer Sentiment Index, for November will play their roles afterward. During the meantime, US-China trade/political headlines could keep the driver's seat.
While US activity numbers are expected to flash upbeat readings, Canadian data could soften. “Retail sales will round out the week's data flow, with TD and the wider market looking for a 0.3% decline in September. Motor vehicles will weigh on the headline print after a pullback in auto sales, leaving the ex-autos measure down just 0.1%, while volumes should see a more substantial decline owing to higher consumer goods prices. This would still leave retail volumes up ~1% (annualized) for Q3, a slight pickup from the 0.4% increase in Q2 which contributed to the weakest quarter of household consumption since 2012,” says TD Securities.
Technical Analysis
With the five-month-old descending resistance line limiting near-term upside around 1.3330, the quote is likely declining towards 1.3200 and short-term rising trend line, at 1.3180.
additional important levels
| Overview | |
|---|---|
| Today last price | 1.3278 |
| Today Daily Change | -4 pips |
| Today Daily Change % | -0.03% |
| Today daily open | 1.3282 |
| Trends | |
|---|---|
| Daily SMA20 | 1.3191 |
| Daily SMA50 | 1.3216 |
| Daily SMA100 | 1.3208 |
| Daily SMA200 | 1.3277 |
| Levels | |
|---|---|
| Previous Daily High | 1.3326 |
| Previous Daily Low | 1.327 |
| Previous Weekly High | 1.3272 |
| Previous Weekly Low | 1.3212 |
| Previous Monthly High | 1.3349 |
| Previous Monthly Low | 1.3042 |
| Daily Fibonacci 38.2% | 1.3291 |
| Daily Fibonacci 61.8% | 1.3305 |
| Daily Pivot Point S1 | 1.3259 |
| Daily Pivot Point S2 | 1.3236 |
| Daily Pivot Point S3 | 1.3202 |
| Daily Pivot Point R1 | 1.3316 |
| Daily Pivot Point R2 | 1.335 |
| Daily Pivot Point R3 | 1.3373 |


Dear {{ person.first_name }}
A new {{ application_name }} application has been assign to you. You can view the application by logging in here
Kind Regards Department of Parks and Wildlife Bob Parks


Posted: 2016-10-19
, Modified: 2016-10-19
Tags: none
Threads
- PMI - get some results!
- SoS - chapters 2 and 3
- DL: do experiments suggested in DL generalization (Mon, Tue)
- (*) NN learns DL. (Mon, Tue) - Wrote up progress so far, where I am stuck.
- Papers
- [HM16] on unsupervised learning (went through 1st half, Tue)
- [HMR16] on dynamical system learning (read blog post Tue)
- Come up with a class of MDPs on exponential space that is interesting and tractable. Thoughts
- Understand provable guarantees on MDP’s first
- Alexa references
Analyze Arora and Ge’s NMF algorithm in the presence of noise. Exactly how much noise can it tolerate?
Other papers
- TODO Read this paper: [CFP16] Assessing significance in a Markov chain without mixing
Talk with Arora 10/19 (Wed)
Dynamical systems + MDP!
Wonderings
- Can we generalize the random walk of the context vectors? There’s no reason to think that context vectors just drift on the sphere. (p. 139)
- Make it a RBM. Say with bounded degree. (There are ways to learn - see the factored MDP paper. We don’t care about MDP here, so it’s easier.)
- For example, one node (dimension) could simply control output of common words.
- Given the observations, whose probs are \(\propto e^{w^TAc}\), learn the RBM. (Note we can replace \(w\) by \(A^Tw\)… but if \(c\) is in larger space, then it’s not obvious how to learn the \(A\)! Can we modify the word embeddings to deal with this? Beware of difficulties… HMMs usually assume full column-rank observations, violated here. Look at the proper hard instance for HMM. - the version I saw with noisy parity wasn’t quite a HMM)
- Prereq: given \((x,h)\) how to learn RBM or Bayes net? (When \(W\)’s entries are small enough, can do via MCMC estimation of partition function and optimization of log-likelihood. Otherwise, is hard worst-case.)
- I’m confused! There seems to be a line of work on factorial MDP’s. However, where are the basic results about learnability of Bayes nets? Learning the model for FMDP’s is strictly harder—why so much work on this (with too much assumptions, or weak results) without results on learning Bayes nets?
- Bresler.
- cf. work on continuous HMM’s. Work on factored HMMs? Any bounds when hidden state has larger dimension? Also, adapt HMM learning to vector observations. (Is the natural generalization a factored prob model rather than a dynamical system? Note probabilistic linear dynamical system IS straightforward generalization of HMM, but the factored prob model is not. Weird generalization though, because only having states \(\{e_1,\ldots, e_n\}\) seems decoupled - can couple together any way you want.) @Andrej on this.
- When state has larger dimension, need overcomplete tensor factorization.
- Start with: given an HMM with both transitions and observations being RBMs (say of degree at most 2), observations don’t “lose info” (analogue of full column rank), infer RBM. (Z is over words that exist). Breaks symmetries - the various dimensions are important now?
- Dictionary learning experiment
- The kernel DL I want is different from in the literature. There they want \(\Phi(Y) \approx \Phi(A)X\), here we want \(\Phi(Y) \approx \Phi(AX)\). I.e. we want to maximize \(K(Y,AX)\) where \(X\) is restricted to be sparse. Usual algorithms break down here, but can still consider \(K(Y,AX) + \ve{X}_1\). (137)
- Use kernel in PMDH16.
- RL questions (135)
- Given a (continuous) space of policies, converge to a local min in the space of policies.
- Find some measure of complexity of a class of policies. Branching is important. (Getting limited info from other policies…) Get a bound independent of number of states, involving this complexity.
- Example to keep in mind: \(2^n\) strategies all branching off into different rewards at end of their paths.
- Alternatively, complexity of class of models of environment.
- What is the VC dimension bound for contextual (expert) bandits? Also look at the contextual MDP paper, cf. EXP4.
- [ALA16] open question
- Scraps
- Right \(\la\), how do well without learning model?
- SoS, minimax, etc.
- EXP3:Scrible:EXP4::UCB1:?:? (LinUCB? RUCB?)
- Increasing \(\ga\) towards 1 (simulated annealing, temperature schedule…)


My site will be one page and consist of the following sections:
Intro:
A brief statement explaining the purpose of the website, and the very
basics of layers.
Opacity:
This will consist of a small description of opacity. To the left
or right of the description will be a slider that has percentages from 0 - 100% and a picture where
you will see the effects of opacity.
Blending Mode:
Again, a small description of what blending mode does and then
three buttons or menu that shows three options and a picture that changes with each option.
Masks:
A small description of masks, a picture to edit, and a two boxes (white and black)
to the side of the picture. This section you can erase part of the picture if you have black selected and
bring part of it back if you have white selected.
Extra (3d Layers):
If I have time, this section will show layers of a final project in 3d.
Contact:
This section will contain a simple contact form, my professional email address, and
additional links LinkedIn, GitHub, and my portfolio website.


[ all classes ]
[ opennlp.tools.postag ]
Coverage Summary for Class: POSSampleEventStream (opennlp.tools.postag)
| Class | Class, % | Method, % | Line, % |
|---|---|---|---|
| POSSampleEventStream | 100% (1/ 1) | 80% (4/ 5) | 93.8% (15/ 16) |
1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18
19 package opennlp.tools.postag;
20
21 import java.util.ArrayList;
22 import java.util.Iterator;
23 import java.util.List;
24
25 import opennlp.tools.ml.model.Event;
26 import opennlp.tools.util.AbstractEventStream;
27 import opennlp.tools.util.ObjectStream;
28
29 /**
30 * This class reads the {@link POSSample}s from the given {@link Iterator}
31 * and converts the {@link POSSample}s into {@link Event}s which
32 * can be used by the maxent library for training.
33 */
34 public class POSSampleEventStream extends AbstractEventStream<POSSample> {
35
36 /**
37 * The {@link POSContextGenerator} used
38 * to create the training {@link Event}s.
39 */
40 private POSContextGenerator cg;
41
42 /**
43 * Initializes the current instance with the given samples and the
44 * given {@link POSContextGenerator}.
45 *
46 * @param samples
47 * @param cg
48 */
49 public POSSampleEventStream(ObjectStream<POSSample> samples, POSContextGenerator cg) {
50 super(samples);
51
52 this.cg = cg;
53 }
54
55 /**
56 * Initializes the current instance with given samples
57 * and a {@link DefaultPOSContextGenerator}.
58 * @param samples
59 */
60 public POSSampleEventStream(ObjectStream<POSSample> samples) {
61 this(samples, new DefaultPOSContextGenerator(null));
62 }
63
64 @Override
65 protected Iterator<Event> createEvents(POSSample sample) {
66 String[] sentence = sample.getSentence();
67 String[] tags = sample.getTags();
68 Object[] ac = sample.getAddictionalContext();
69 List<Event> events = generateEvents(sentence, tags, ac, cg);
70 return events.iterator();
71 }
72
73 public static List<Event> generateEvents(String[] sentence, String[] tags,
74 Object[] additionalContext, POSContextGenerator cg) {
75 List<Event> events = new ArrayList<Event>(sentence.length);
76
77 for (int i = 0; i < sentence.length; i++) {
78
79 // it is safe to pass the tags as previous tags because
80 // the context generator does not look for non predicted tags
81 String[] context = cg.getContext(i, sentence, tags, additionalContext);
82
83 events.add(new Event(tags[i], context));
84 }
85 return events;
86 }
87
88 public static List<Event> generateEvents(String[] sentence, String[] tags,
89 POSContextGenerator cg) {
90 return generateEvents(sentence, tags, null, cg);
91 }
92 }


Home
Sign in
Live Chat
Topics
Guest
Contact Us
Name
Email Address
Subject
Choose One:
Medical issues
Relationship issues
Legal issues
Spiritual issues
Addiction issues
School
Psychological issues
Message
Send Message
Physical Address
251 Main Avenue
Ferndale
Randburg 2194
Tel:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>
P:
(123) 456-7890
Email
ops@mobieg.co.za


Visit Hactoberfestfor more info!
Hacktoberfest® is open to everyone in our global community. Whether you’re a developer, student learning to code, event host, or company of any size, you can help drive growth of open source and make positive contributions to an ever-growing community. All backgrounds and skill levels are encouraged to complete the challenge.


About Us
Pat loves cookies. Pat loves Seattle. Pat loves salmon.
One day, Pat decided to put all his loves together and came up with salmon cookies. These delectables soon became so popular amongst his family and friends, Pat decided to share them with the rest of his Seattle community. Now we are established at five locations in the Greater Seattle area.
- Alki
- 123 Front Way St
- West Seattle
- 1st and Pike
- 123 Pike St
- Seattle
- SeaTac Airport
- 123 Airport Way St
- Tukwila
- Seattle Center
- 123 Code St
- Seattle
- Capitol Hill
- 123 Cap Way
- Capitol Hill
In addition to cookies, we have apparel and all the tools you need to make salmon cookies, right in your own kitchen. Make sure you check out all the gear we have in our stores!
There's something for everyone: frosted sugary cookies for those with a sweet tooth, tees in every size to fit every member of your family, or cute cookie cutters for the avid baker!
We hope to see you soon.
Contact Us
Our main office is located at 1st and Pike, and we are available by phone during hours of operation. We try to answer emails within 48 hours, so be patient if you send us an email at salmoncookies@mail.mail


Are you sure you want to clear all conversations
Are you sure you want to clear all messages from this conversation


 Stevenson is magnificent’ Evening Standard
Photo by Johan Persson
A Catherine Schreiber, Paula Marie Black and Young Vic production Music & Lyrics by John Kander and Fred Ebb Book by David Thompson Direction & Choreography by Susan Stroman
HHHHH
‘A shocking, gripping, superbly staged, fabulously well-performed show’ Mail on Sunday
Photo by Johan Personn
A 1927 / Young Vic production Created by 1927 Directed & written by Suzanne Andrade Film, Animation & Design Paul Barritt
HHHHH
‘Groundbreaking with strokes of genius’ Daily Telegraph
Photo by Bernhard Muller
A Young Vic/Joshua Andrews co-production By Tennessee Williams Directed by Benedict Andrews
HHHHH
‘Benedict Andrews’ version steams off the stage with pain, excitement and clamour’ The Observer
Photo by Johan Persson
A C.I.C.T. / Théâtre des Bouffes du Nord production co-produced by Theatre for a New Audience, New York, Les Théâtres de la ville du Luxembourg; Théâtre d’Arras / Tandem Arras Douai; Théâtre du Gymnase, Marseille; Warwick Arts Centre; Holland Festival, Amsterdam; Attiki Cultural Society, Athènes; Musikfest Bremen; Théâtre Forum Meyrin, Geneva; C.I.R.T. and Young Vic. Directed by Peter Brook and Marie-Hélène Estienne
HHHH
‘Sublime’ The Independent
Photo by TBC
By Arthur Miller Directed by Ivo van Hove
HHHHH
‘One of the great theatrical productions of the decade. See it.’ The Times
Photo Jan Versweyveld
At the Duke of York’s
By Henrik Ibsen Directed by Carrie Cracknell
HHHH
‘There is so much to admire in this marvellous production… Teriffic’ The Times
Photo by Richard Hubert Smith
By Aimé Césaire From a translation by Ralph Manheim Directed by Joe Wright
HHHH
‘Right from the start, we know we’re in for something special’ Evening Standard
Photo by TBC


--- layout: post title: Researching weather with a laser - The Weather Network date: '2011-11-13T14:10:00.000-05:00' author: Bob Sica tags: - lidar - coupling - science - purplecrowlidar - public modified_time: '2011-12-21T12:48:50.458-05:00' blogger_id: tag:blogger.com,1999:blog-736339229338318027.post-964960395586576634 blogger_orig_url: http://blog.purplecrowlidar.ca/2011/11/researching-weather-with-laser-weather.html ---


--- layout: post title: Execute it description: "Geeking out - Part 1" modified: 2015-03-09 tags: [mastermind, chmod] image: feature: make-your-own-path.jpeg comments: false ---
So, I am currently working on a Mastermind game in ruby and to run my program I needed to write an executable file. So cool! I have never written an executable before!
Most common files we have are data files, text or images, for example. Executable file contains instructions for the computer to execute and just by specifying the path to the file in the command line the code is run. This is not the same as any file with some code, because to run a code in a regular file we would need enter into command line something like:
{% highlight ruby %} rubyOn this occasion I need to be able to run my code without using the ruby command, which in itself is just another executable file that was placed when ruby was installed on your system. Instead, I should be able to type the path to this file from my command line and the code will be executed.
Here's my project structure:
mastermind |____bin | |__mastermind | |____lib (contains bunch of ruby files) | |____spec (tests)
The code to be run will live inside the bin/mastermind. It is a convention to put executable files into bin directory. To execute the code in the file I want to be able to just say:
{% highlight ruby %} bin/mastermind #if I am currently within the mastermind folder {% endhighlight %}So how do we make a file executable? What happens now if we type in the above in the command line? Let's run and see what we get. This is what I got (the little emoticon is my custom prompt):
{% highlight ruby %} 👻 mastermind [master] ⚡ bin/mastermind zsh: permission denied: bin/mastermind {% endhighlight %}A good place to start would be to check my current permissions for this file:
{% highlight ruby %} 👻 mastermind [master] ⚡ ls -l bin #asking for detailed list of bin directory content total 8 -rw-r--r-- 1 Jarkyn staff 312 09 Mar 15:30 mastermind {% endhighlight %}So if you know exactly what this means and how it works, you may want to skip to the end :). Otherwise, stay tuned!
There are few things we can do with the files, we can read them - r, and we can write - w - to them or we can execute them - x, three generic operations in total, represented by three swithches: rwx. Lets have a detailed look at the output we got when we ran ls -l bin:
____owner permission switches (read - on, write - on, execute - off) | ____group permission switches (read - on, write - off, execute - off) | | ____permission switches for everyone other than owner or group | | | (read - on, write - off, execute - off) ∨ ∨ ∨ - rw- r-- r-- 1 Jarkyn staff 312 09 Mar 15:30 mastermind ∧ ∧ ∧ ∧ ∧ ∧ | | | | | |__file name | | | |__size |__date modified | | | | | |__group file belongs to | | | |__file owner | |_____first dash is not significant to us in this case, it tells that the item is just a file; this is replaced by letter 'd' if item is a directory (other options exist as well, to denote symlink for example)
We just need to make sure that all users are able to execute my little program, therefore we need to turn last switch for each user type. Here's a command we are going to use: chmod
Here's a simple explanation from Wikipedia; essentially it allows you to change access permissions to files or folders. In my case I want to turn the third switch on for all user types. This is the result I want:
{% highlight ruby %} rwx r-x r-x {% endhighlight %}I will show you the easy version of this command:
{% highlight ruby %} chmod a+x bin/mastermind {% endhighlight %}Let's break down the command:
chmod
: "change permissions"a
: "for all user types"+
: "add" (you could use "-" to remove)x
: "executable permission"bin/mastermind
: path to the file to apply these toAnd now if we check our permissions again:
{% highlight ruby %} 👻 mastermind [master] ⚡ ls -l bin -rwxr-xr-x 1 Jarkyn staff 312 09 Mar 15:40 mastermind {% endhighlight %}So far, we essentially told the system to make this file executable. But there are couple of other things I wanted to look at as well, and have not mentioned yet:
So if you would like to look at those things as well, check out my upcoming posts: Change Mode or Geeking out - Part 2 and TBC or Geeking out - Part 3.


Install plugin
brew install git-extras
Some useful commands
git summary --line git effort --above 15
Visit the official website to learn more about Git Extras Commands


Name: Eden Hazard
Age: 25 yrs
Address: Darwin
Gmail<EMAIL_ADDRESS>Phone Number: xx-xx-xx
DOB: DD/MM/YY
×
Your Credit Card Info
Credit Card number
XXXX-XXXX-XXXX-9867
Card Expery Month
May
Card Expery Year
2022
Card Holder Name
Eden Hazard
Accepted Cards
You can update your card details below:-
Name on the Card
Credit card number
Exp Month
Exp Year
CVV
Update
credit card info
Contact Us
×
Contact us
Go Back


Table 1 - all paths (not cut at intersection)
inside or outside
Startpoint (lon/lat)
Endpoint (lon/lat)
Length in Meters
Table 2 - all paths (cut at intersection)
inside or outside
Startpoint (lon/lat)
Endpoint (lon/lat)
Length in Meters


works on Chrome, doesn't work on IE11
Step 1 (to break)
Step 2
col1
col2
col3
col4
Step 3 (to fix)
01
02
03
04


Rafael Marins Féres
What Rafael is saying...
Rafael Marins Féres
"8º Semester student of Information Systems at UnilaSalle-RJ. Looking for a job ASAP!"


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object edu.nps.moves.logger.DisLogger
public class DisLogger
Logs DIS packets to XML format. You can easily receive DIS packets off the wire faster than they can be logged to XML, so you need to be careful about that. With a 2 GHz core duo and OSX, on a macbook pro laptop drive, you can log roughly 1,000 packets per second.
Since we cannot hold all the PDUs in memory at once, we set up a rotating system in which packets are read into a list, then, when the list is full, the list is handed off to a separate thread for marshalling to XML. This gives us at least a chance of not dropping packets while writing to file.
The classes here and in LogReplay are intended to be used from the command line, but it should be easy to wrap a GUI around them.
the classes are configured via a properties file. this defines the multicast group to listen on, the directory to which files should be written, etc.
| Field Summary | |
|---|---|
static int |
MAX_PDU_LOGFILE_SIZE
|
static int |
MAX_PDU_SIZE
Maximum PDU size. |
static int |
READ_TIMEOUT
How long to wait for a packet to arrive, in ms, before throwing an exception |
| Constructor Summary | |
|---|---|
DisLogger(java.util.Properties loggerProperties)
Create a new DIS logger with the given properties object. |
| Method Summary | |
|---|---|
boolean |
finishedWriting()
We may have broken out of the netowrk read loop, but the writer task is still involved in flushing out the already captured PDUs to disk. |
static void |
main(java.lang.String[] args)
Entry point. |
void |
run()
Run the logger. |
void |
setDone()
Breaks us out of network read log loop (perhaps after READ_TIMEOUT has passed |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
public static final int MAX_PDU_SIZE
public static final int MAX_PDU_LOGFILE_SIZE
public static final int READ_TIMEOUT
| Constructor Detail |
|---|
public DisLogger(java.util.Properties loggerProperties)
| Method Detail |
|---|
public void setDone()
public void run()
run
in interface java.lang.Runnable
public boolean finishedWriting()
public static void main(java.lang.String[] args)
args
-
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


§661-2 Judgment against claimant when. Upon the trial of any cause in which any counterclaim or other demand is set up on the part of the State against any person making claim against the State, the court shall, without the intervention of a jury, hear and determine the claim or demand both for and against the State and claimant; and if upon the whole case it finds that the claimant is indebted to the State, it shall render judgment to that effect. [L 1894-5, c 26, §2; RL 1925, §2670; am L 1929, c 213, §2; RL 1935, §4421; RL 1945, §10476; RL 1955, §245-2; HRS §661-2; am L 1972, c 164, §1(b)]
Cross References
Costs, bond, when State a party, see §607-24.
Money paid under protest, suit to recover, see §40-35.