VIRT-TOP
Section: Virtualization Support (1)Updated: 2012-06-22
Index Return to Main Contents
NAME
virt-top - 'top'-like utility for virtualization statsSUMMARY
virt-top [-options]DESCRIPTION
virt-top is a top(1)-like utility for showing stats of virtualized domains. Many keys and command line options are the same as for ordinary top.It uses libvirt so it is capable of showing stats across a variety of different virtualization systems.
OPTIONS
- -1
- Display physical CPUs by default (instead of domains). When virt-top is running, use the 1 key to toggle between physical CPUs and domains display.
- -2
- Display network interfaces by default (instead of domains). When virt-top is running, use the 2 key to toggle between network interfaces and domains display.
- -3
- Display block devices (virtual disks) by default (instead of domains). When virt-top is running, use the 3 key to toggle between block devices and domains display.
- -b
- Batch mode. In this mode keypresses are ignored.
- -c uri or --connect uri
-
Connect to the libvirt URI given.
To connect to QEMU/KVM you would normally do -c qemu:///system
To connect to Xen on the same host, do -c xen:///
To connect to libvirtd on a remote machine you would normally do -c qemu://host/system
If this option is not given then virt-top connects by default to whatever is the default hypervisor for libvirt, although this can be overridden by setting environment variables.
See the libvirt documentation at <http://libvirt.org/uri.html> for further information.
- -d delay
- Set the delay between screen updates in seconds. The default is 3.0 seconds. You can change this while virt-top is running by pressing either s or d key.
- -n iterations
- Set the number of iterations to run. The default is to run continuously.
- -o sort
-
Set the sort order to one of:
cpu (sort by %CPU used),
mem (sort by total memory),
time (sort by total time),
id (sort by domain ID),
name (sort by domain name),
netrx (sort by network received bytes),
nettx (sort by network transmitted bytes),
blockrdrq (sort by block device [disk] read requests),
blockwrrq (sort by block device [disk] write requests).
While virt-top is running you can change the sort order using keys P (cpu), M (memory), T (total time), N (domain ID), F (interactively select the sort field).
- -s
- Secure mode. Currently this does nothing.
- --hist-cpu secs
- Set the time in seconds between updates of the historical %CPU at the top right of the display.
- --csv file.csv
-
Write the statistics to file file.csv. First a header is written
showing the statistics being recorded in each column, then one line is
written for each screen update. The CSV file can be loaded directly
by most spreadsheet programs.
Currently the statistics which this records vary between releases of virt-top (but the column headers will stay the same, so you can use those to process the CSV file).
Not every version of virt-top supports CSV output - it depends how the program was compiled (see README file in the source distribution for details).
To save space you can compress your CSV files (if your shell supports this feature, eg. bash):
virt-top --csv >(gzip -9 > output.csv.gz)
You can use a similar trick to split the CSV file up. In this example the CSV file is split every 1000 lines into files called output.csv.00, output.csv.01 etc.
virt-top --csv >(split -d -l 1000 - output.csv.)
RHEL 6 provides a short Python script called "processcsv.py" which can be used to post-process the CSV output. Run it like this:
virt-top --csv data.csv processcsv.py < data.csv
This creates or overwrites the following files in the current directory:
global.csv domain<NNN>.csv
"global.csv" will contain the global data. One "domain<NNN>.csv" file will also be created for each domain with ID "NNN", containing the per-domain data.
- --no-csv-cpu
- Disable domain CPU stats in CSV output.
- --no-csv-mem
- Disable domain memory stats in CSV output.
- --no-csv-block
- Disable domain block device stats in CSV output.
- --no-csv-net
- Disable domain network interface stats in CSV output.
- --debug filename
-
Send debug and error messages to filename.
To send error messages to syslog you can do:
virt-top --debug >(logger -t virt-top)
See also REPORTING BUGS below.
- --init-file filename
- Read filename as the init file instead of the default which is $HOME/.virt-toprc. See also INIT FILE below.
- --no-init-file
- Do not read any init file.
- --script
- Script mode. There will be no user interface. This is most useful when used together with the --csv and -n options.
- --stream
- Stream mode. All output is sent to stdout. This can be used from shell scripts etc. There is no user interface.
- --block-in-bytes
- Show I/O statistics in Bytes. Default is shown in the number of Requests.
- --end-time time
-
The program will exit at the time given.
The time may be given in one of the following formats:
-
For example to run the program for 3 minutes you could do:
virt-top --end-time +00:03:00
or:
virt-top --end-time +180
Not every version of virt-top supports this option - it depends how the program was compiled (see README file in the source distribution for details).
- --help
- Display usage summary.
KEYS
Note that keys are case sensitive. For example use upper-case P (shift P) to sort by %CPU. ^ before a key means a Ctrl key, so ^L is Ctrl L.- space or ^L
- Updates the display.
- q
- Quits the program.
- h
- Displays help.
- s or d
- Change the delay between screen updates.
- B
- Toggle Block I/O statistics so they are shown in either bytes or requests.
- 0 (number 0)
- Show the normal list of domains display.
- 1 (number 1)
- Toggle into showing physical CPUs. If pressed again toggles back to showing domains (the normal display).
- 2
- Toggle into showing network interfaces. If pressed again toggles back to showing domains.
- 3
- Toggle into showing block devices (virtual disks). If pressed again toggles back to showing domains.
- P
- Sort by %CPU.
- M
- Sort by total memory. Note that this shows the total memory allocated to the guest, not the memory being used.
- T
- Sort by total time.
- N
- Sort by domain ID.
- F
- Select the sort field interactively (there are other sort fields you can choose using this key).
- W
-
This creates or overwrites the init file with the current settings.
This key is disabled if --no-init-file was specified on the command line or if overwrite-init-file false is given in the init file.
INIT FILE
When virt-top starts up, it reads initial settings from the file .virt-toprc in the user's home directory.The name of this file may be overridden using the --init-file filename command line option or may be disabled entirely using --no-init-file.
The init file has a simple format. Blank lines and comments beginning with # are ignored. Everything else is a set of key value pairs, described below.
- display task|pcpu|block|net
- Sets the major display mode to one of task (tasks, the default), pcpu (physical CPUs), block (block devices), or net (network interfaces).
- delay secs
- Sets the delay between display updates in seconds.
- hist-cpu secs
- Sets the historical CPU delay in seconds.
- iterations n
- Sets the number of iterations to run before we exit. Setting this to -1 means to run continuously.
- sort cpu|mem|time|id|name|...
- Sets the sort order. The option names are the same as for the command line -o option.
- connect uri
- Sets the default connection URI.
- debug filename
- Sets the default filename to use for debug and error messages.
- csv filename
- Enables CSV output to the named file.
- csv-cpu true|false
- Enable or disable domain CPU stats in CSV output.
- csv-mem true|false
- Enable or disable domain memory stats in CSV output.
- csv-block true|false
- Enable or disable domain block device stats in CSV output.
- csv-net true|false
- Enable or disable domain network interface stats in CSV output.
- batch true|false
- Sets batch mode.
- secure true|false
- Sets secure mode.
- script true|false
- Sets script mode.
- stream true|false
- Sets stream mode.
- block-in-bytes true|false
- Show block device statistics in bytes.
- end-time time
- Set the time at which the program exits. See above for the time formats supported.
- overwrite-init-file false
- If set to false then the W key will not overwrite the init file.
Note that in the current implementation, options specified in the init file override options specified on the command line. This is a bug and this behaviour may change in the future.
NOTES
Block I/O statistics
This I/O value is the amount of I/O since the previous iteration of virt-top. To calculate speed of I/O, you should divide the number by delay secs.NETWORK RX BYTES AND PACKETS
Libvirt/virt-top has no way to know that a packet transmitted to a guest was received (eg. if the guest is not listening). In the network RX stats, virt-top reports the packets transmitted to the guest, on the basis that the guest might receive them.In particular this includes broadcast packets. Because of the way that Linux bridges work, if the guest is connected to a bridge, it will probably see a steady ``background noise'' of RX packets even when the network interface is idle or down. These are caused by STP packets generated by the bridge.
DEBUGGING LIBVIRT ISSUES
virt-top tries to turn libvirt errors into informative messages. However if libvirt initialization fails then this is not possible. Instead you will get an obscure error like:
libvir: error : Unknown failure Fatal error: exception Libvirt.Virterror(...)
To see the cause of libvirt errors in more detail, enable libvirt debugging by setting this environment variable:
export LIBVIRT_DEBUG=1
SEE ALSO
top(1), virsh(1), <http://www.libvirt.org/ocaml/>, <http://www.libvirt.org/>, <http://et.redhat.com/~rjones/>, <http://caml.inria.fr/>AUTHORS
Richard W.M. Jones <rjones @ redhat . com>COPYRIGHT
(C) Copyright 2007 Red Hat Inc., Richard W.M. Jones http://libvirt.org/This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
REPORTING BUGS
Bugs can be viewed on the Red Hat Bugzilla page: <https://bugzilla.redhat.com/>.If you find a bug in virt-top, please follow these steps to report it:
- 1. Check for existing bug reports
- Go to <https://bugzilla.redhat.com/> and search for similar bugs. Someone may already have reported the same bug, and they may even have fixed it.
- 2. Capture debug and error messages
-
Run
virt-top --debug virt-top.log
and keep virt-top.log. It contains error messages which you should submit with your bug report.
- 3. Get version of virt-top and version of libvirt.
- In virt-top, press the h (help) key, and write down the version of virt-top and the version of libvirt. They are shown in the first line.
- 4. Submit a bug report.
-
Go to <https://bugzilla.redhat.com/> and enter a new bug.
Please describe the problem in as much detail as possible.
Remember to include the version numbers (step 3) and the debug messages file (step 2).
- 5. Assign the bug to rjones @ redhat.com
-
Assign or reassign the bug to rjones @ redhat.com (without the
spaces). You can also send me an email with the bug number if you
want a faster response.
Index
This document was created by man2html, using the manual pages.
Time: 05:29:12 GMT, December 24, 2015


REST API:
| Route | Method | Description |
| /api/chat/new | GET | New message: Creates a new message to send to a user |
| /api/chat/view | GET | Chats: Gets all the conversations the user has had with other users |
| /api/chat/view/user | GET | Profiles: Gets the other user's profile information |
| /api/chat/home | GET | Homepage: Gets the current status of friends list (online or offline); displays if you have had a previous conversation with them as well |
Server Logic:
The user will register with a username and password that the server will store, redirecting the user to a login screen where they will be able to login (and not register again), which will then redirect them to the home location (homepage of the app) to see their data. When chatting with another user, the server will transport and display the messages using a socket connection.
Server Fetches:
The user will register using POST which allows the user information to be fetched from the database at sign-in. When logging in and whether they entered the correct login information, the user will enter their credentials in order to GET access their account from the database. The user will have friends, therefore friend requests will be available. Using POST the friend request will be sent to the targeted account allowing them to accept or deny the request. After the login process is completed and friend requests have been accepted the user will be able to chat amongst friends and different groups. The chatting process will use POST to send messages and GET will be used so the recipient can read the sent messages.
Tooling and Libraries
All external tools and libraries used are as follows:
Client Logic:
JavaScript's logic and data processing responsibilities will include the following features:
Server Fetches:
All expected server requests will include the following:
Tooling and Libraries:
All external tools and libraries used are as follows:
REST Client App (HTTP + Modules), due April 12, 2021.
I created an app that allows a user to search for a Pokémon by name or ID number. The app uses PokéAPI to retrieve data on the input provided, including the Pokémon's name, ID, and the animated sprites the Pokémon used in Pokémon Black Version and Pokémon White Version (2011). While the API has data for all Pokémon through Generation VIII, it only has the sprites available for Generation I through V.
User Stories
A regular user will be able to log in to the app (or register if they do not have an account), see a list of their chats, and talk to other users.
An administrator has the abilities of a regular user, plus the ability to view data of the app, such as how many users are signed up, how many are active, etc.
Frontend Features
The user will encounter a login screen to login with their username and password in order to access their chats. If they are new to the app, they will have to register to create an account. Once logging in, the user will see a display of their chats with different users on the left side of their window in a panel. When a user clicks on another user, their messages will appear. If they have never contacted the other user before, their message screen will be blank. They will also be able to see which users are online and offline, available or unavailable.
Backend Features
The server will have to authenticate the user or register the user. The server will send and receive (display) messages from one user to another in order to make the communication actually happen.
Database Features
The database will have to store the user’s information, username and password, so the user can login and not have to re-register every time. The database will also have to store user-to-user messages in order to have a conversation history.
Our proposed idea for a full stack app is creating a chat application. With the little amount of time we will have to implement the idea, we decided this would be the best way to go. Chat applications are something that we use on a daily basis, whether it be Discord, WhatsApp, Facebook Messenger, etc. They are an easy way to communicate with others remotely and can be convenient, especially nowadays with Covid-19. Although there are many chat applications out there that do many of the same things, we believe that user experience and user interface design are two major features to consider when someone decides on which app they prefer. Our goal for our chat application is to fulfill these two features using the knowledge we are learning in our Web Application course.
Abstract: As a team we will create a chat application. Similar to Discord and other applications, the app will solve several issues. It will be the solution for students and friends to talk during the pandemic. This application will also solve the hideous difficulty of finding groups a user would like to be a part of, may that be any topic such as programming or video games. The audience for this app will gear towards groups of long time friends and students that will need to connect with classmates and teachers as well as streamers/gamers. The features of this app will be as follows:
Rebecca Dummet: Senior graduating in Spring 2022.
Cassidy Osgood: Computer Science senior at UNO expecting to graduate in May 2021. Computer science interests are game development/design and web development.


Sun, Jul 27, 2014
Research Methodology is compulsory subject for my study. In the course, the lecturer spoke about ethics, plagiarism, and types of innovation. In particular, I do not agree with her emphasize on the technicalities of research over the spirit of research. I also do not agree with her saying that reinterpretation is the lowest kind of innovation. And hence the following ranting. In the study of economy, we have this old maxim: people response to incentives, and the rest is commentaries.
Sun, Jul 13, 2014
I have just started to learn about concurrency. Communicating Sequential Processes is one of the seminal book in this field, which is more often mentioned than studied. This is the reason I wish to write a series of blog posts about the book, which mainly served as some kind of reading notes for myself, and additionally, a summary for those who are interested, and to lure them into serious study. Beside the original book,Theory and Practice of Concurrency, a more recent book written by A.W.
Fri, Jul 11, 2014
Reflect, Refine, Refactor Today I have read the book “Show Your Work” by Austin Kleon, the very same author who brought us “Steal Like an Artist”. Following the tradition of his previous book, the author serves us nuggets of advices, One of them that particularly resonates with me is: Become a documentarian of what you do. In the context of exposing yourself to the world, which is the theme of this book, the documentation of your working process serves 2 purposes: By far it is a superior way to showcase your work and your contributions than a traditional resume.


Requestool workpage
start Requests
no data
#
requestUrl
method
responseStatus
successCount
failCount
repeatTimes
timeInterval
successCheck(optinal)
failCheck(optinal)
delete
clear log
How TO USE?
nowaku@2019
github


Dr. Adonia Hsu, Board-Certified Veterinary Cardiologist
Dr. Adonia Hsu is a board-certified veterinary cardiologist. She received her VMD in 2003 from the University of Pennsylvania School of Veterinary Medicine. She practiced general veterinary medicine in Park Slope, Brooklyn, NY for several years before deciding to pursue the specialty of cardiology. Dr. Hsu completed a one year small animal internship at Advanced Veterinary Care Center in Lawndale, CA followed by a residency in cardiology at the University of California Davis. Dr. Hsu has a special interest in interventional cardiology, including transvascular PDA occlusion, balloon valvuloplasty for pulmonic stenosis, and transvenous pacemaker placement. She has an interest in cardiology not only for dogs and cats, but also other species of animals from hamsters to horses. Dr. Hsu joins us from Seattle, where she was voted one of the Top Veterinarians in Seattle for 2011 in Seattle Met magazine.
Locations
VCA Emergency Animal Hospital & Referral Center
2317 Hotel Circle South
San Diego, CA 92108
Tel:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>
Desert Veterinary Specialists
42-065 Washington Street, Suite D
Palm Desert, CA 92211-8024
Tel:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>


Abstract
Drosophila melanogaster is a powerful, long-standing model for metazoan development and gene regulation. We profiled chromatin accessibility in almost 1 million and gene expression in half a million nuclei from overlapping windows spanning the entirety of embryogenesis. Leveraging developmental asynchronicity within embryo collections, we applied deep neural networks to infer the age of each nucleus, resulting in continuous, multimodal views of molecular and cellular transitions in absolute time. We identify cell lineages; infer their developmental relationships; and link dynamic changes in enhancer usage, transcription factor (TF) expression, and the accessibility of TFs’ cognate motifs. With these data, the dynamics of enhancer usage and gene expression can be explored within and across lineages at the scale of minutes, including for precise transitions like zygotic genome activation.
* co-first authors ** corresponding authors


--- layout: post title: "Day 27 - Bar Brothers Workout" subtitle: "Today I'm home alone, and I can't go out for a walk, which means all my workouts should be cardio at home." date: 2019-11-17 background: '/img/posts/intro-barbrothers.png' ---
So training at home is something simple to get off of, but it's not that I've had a lot of choices.
Today I had a chicken breast with a large salad and peas and carrots, intermediates included apple and apple flavored tea, was excellent and I feel very good, tomorrow morning I start by changing a menu of eating two slices of bread in a tuna with beef, and then see how it affects and helps my weight loss.
Good night.


How to temporarily turn off automatic updates in Windows 10, so your computer won't restart on its own
by Ross James- You can turn off automatic updates in Windows 10 to stop your computer from restarting and updating without your permission.
- However, you can’t turn off automatic updates forever –Windows only lets you push them back for about a month at a time.
- Visit Business Insider’s homepage for more stories.
Windows updates can be like dentist appointments for some people – you know they’re important, but on the other hand, you’re going to do everything to put them off, or get out of it altogether.
Turning automatic updates off means that your computer will only restart when you want it to – no more losing progress to a forced shut down.
Note, however, that you normally can’t turn off automatic updates forever. Using Windows’ Settings app, you can only pause them for up to 35 days at a time.
Updates often close holes that have been discovered in your operating system’s security, so you should still make sure you’re updating when you can.
Check out the products mentioned in this article:
Windows 10 Home (From $US139.99 at Best Buy)
Dell Inspiron 2-in-1 Touchscreen Laptop (From $US799.99 at Best Buy)
How to temporarily turn off automatic updates in Windows 10
1. Press the Windows key on your keyboard. or click the icon at the bottom-left of your screen, and search “Updates.”
2. Select “Check for Updates.”
3. In the menu that opens, select “Advanced Options.”
4. At the bottom of this new page will be a section titled “Pause updates.” In this section, open the drop-down menu and select the date you want to pause updates until. Windows won’t try to update again until it reaches that date. You can push it back for a maximum of 35 days at one time.
You won’t be able to push the date back further until Windows updates on that day, but this can give you some reprieve.
Again, this method is only a temporary fix. It gives you a longer delay between updates, but Windows will update eventually.
There is a more permanent solution for disabling automatic updates. However, it requires having the Professional version of Windows 10, as well as editing the Registry – the database that controls some of your computer’s most basic functions.
Because fiddling with the Registry can cause irreversible damage to your computer, and because Windows updates often come with critical security patches, it’s highly recommended that you don’t seek this solution out without extensive research beforehand.
embed type
product
oEmbedUrl
html
embed type
product
oEmbedUrl
html
Related coverage from How To Do Everything: Tech:
-
How to turn off the touch screen on certain Windows 10 devices, or turn it back on
-
How to invert or change the colours on your Windows computer, to make icons and links easier to see
-
How to set a default printer in Windows 10 so that it’s easier and quicker to print documents
-
How to change the font size on a Windows 10 computer, to make it easier to read text displayed on your screen
-
How to change your background on a Windows 10 device using your settings or a shortcut


Avatica is a framework for building database drivers.
Avatica is defined by a wire API between a client and a server. The Avatica server is an HTTP server, the Avatica client is a JDBC driver, and the wire API is defined by JSON or Protobuf Buffers. The flexibility of the wire API and HTTP transport allows other Avatica clients to be built in any language, implementing any client specification.
Avatica is a sub-project of the Apache Calcite project. Please refer to Calcite for information about the project as a whole.


-
Why trusted subjects are needed?
-
Rushby just proposes a formal model using transition relation to demonstrate
what the demand of the separation kernel is and how to verify the separation
kernel. But in the real scene, how to describe the real operating system and
how to describe the demand of the separation kernel?


Overview
What is D?
D is a general purpose systems and applications programming language. It is a high level language, but retains the ability to write high performance code and interface directly with the operating system API's and with hardware. D is well suited to writing medium to large scale million line programs with teams of developers. D is easy to learn, provides many capabilities to aid the programmer, and is well suited to aggressive compiler optimization technology.
D is not a scripting language, nor an interpreted language. It doesn't come with a VM, a religion, or an overriding philosophy. It's a practical language for practical programmers who need to get the job done quickly, reliably, and leave behind maintainable, easy to understand code.
D is the culmination of decades of experience implementing compilers for many diverse languages, and attempting to construct large projects using those languages. D draws inspiration from those other languages (most especially C++) and tempers it with experience and real world practicality.
Why D?
Why, indeed. Who needs another programming language?
The software industry is continuously evolving at a breakneck pace. New ideas appear, and older ideas are either validated or discarded. What programmers need and want out of a programming language changes. Available memory and computing power have increased by orders of magnitude, as well as the scale of programs being developed.
Compilers are no longer terribly constrained by available computing resources, and so are able to do much more for the programmer. Much more powerful language features have become practical. These features can be difficult to retrofit into existing languages, and when there are enough of these, a new language is justified.
Major Design Goals of D
Everything in designing a language is a tradeoff. Keeping some principles in mind will help to make the right decisions.
- Enable writing fast, effective code in a straightforward manner.
- Make it easier to write code that is portable from compiler to compiler, machine to machine, and operating system to operating system. Eliminate undefined and implementation defined behaviors as much as practical.
- Provide syntactic and semantic constructs that eliminate or at least reduce common mistakes. Reduce or even eliminate the need for third party static code checkers.
- Support memory safe programming.
- Support multi-paradigm programming, i.e. at a minimum support imperative, structured, object oriented, generic and even functional programming paradigms.
- Make doing things the right way easier than the wrong way.
- Have a short learning curve for programmers comfortable with programming in C, C++ or Java.
- Provide low level bare metal access as required. Provide a means for the advanced programmer to escape checking as necessary.
- Be compatible with the local C application binary interface.
- Where D code looks the same as C code, have it either behave the same or issue an error.
- Have a context-free grammar. Successful parsing must not require semantic analysis.
- Easily support writing internationalized applications - Unicode everywhere.
- Incorporate Contract Programming and unit testing methodology.
- Be able to build lightweight, standalone programs.
- Reduce the costs of creating documentation.
- Provide sufficient semantics to enable advances in compiler optimization technology.
- Cater to the needs of numerical analysis programmers.
- Obviously, sometimes these goals will conflict. Resolution will be in favor of usability.
Transitioning to D
The general look of D is like C and C++. This makes it easier to learn and port code to D. Transitioning from C/C++ to D should feel natural. The programmer will not have to learn an entirely new way of doing things.
Using D will not mean that the programmer will become restricted to a specialized runtime vm (virtual machine) like the Java vm or the Smalltalk vm. There is no D vm, it's a straightforward compiler that generates linkable object files. D connects to the operating system just like C does. The usual familiar tools like make will fit right in with D development.
- The general look and feel of C/C++ is adopted. It uses the same algebraic syntax, most of the same expression and statement forms, and the general layout.
- D programs can be written in familiar paradigms, function-and-data, object-oriented, template metaprogramming, functional, or any mix of them.
- The compile/link/debug development model is carried forward from languages like C, although nothing precludes D from being compiled into bytecode and interpreted.
- Exception handling. More and more experience with exception handling shows it to be a superior way to handle errors than error codes.
- Runtime Type Identification. Fully supporting RTTI it enables better garbage collection, better debugger support, more automated persistence, etc.
- D maintains function link compatibility with the C calling conventions. This makes it possible for D programs to access operating system APIs directly. Programmers' knowledge and experience with existing programming APIs and paradigms can be carried forward to D with minimal effort.
- Limited support for function link compatibility with C++ calling conventions. In particular, there is compatibility with C++ name mangling, namespaces, templates, and exceptions.
- Operator overloading. D programs can overload operators enabling extension of the basic types with user-defined types.
- Template Metaprogramming. Parametric polymorphism (aka template metaprogramming) is straightforward in D.
- RAII (Resource Acquisition Is Initialization).
- Custom memory management. There are times in systems programming where developers need alternatives to garbage collection. D also allows for manual memory management, techniques such as reference counting, and the use of specialized memory allocators.
- Down and dirty programming. D retains the ability to do down-and-dirty programming without resorting to referring to external modules compiled in a different language. Sometimes, it's just necessary to coerce a pointer or dip into assembly when doing systems work. D's goal is not to prevent down and dirty programming, but to minimize the need for it in solving routine coding tasks.
Features To Leave Behind
- Support for 16 bit computers. No consideration is given in D for mixed near/far pointers and all the machinations necessary to generate good 16 bit code. The D language design assumes at least a 32 bit flat memory space and supports 64 bit as well.
- Mutual dependence of compiler passes. Having a clean separation between the lexer, parser, and semantic passes makes for an easier to implement and understand language. This means no user-defined tokens and no user-defined syntax.
- Macro systems. Macros are an easy way for users to add very powerful features. Unfortunately, the complexity is pushed off on to the user trying to understand the macro usage, and the result is rarely worth it and not justifiable.
- C/C++ source code compatibility. The use of the preprocessor has made this difficult to achieve without inevitably requiring manual touch up. It's best to leave this to external tools.
- Multiple inheritance. It's a complex feature of debatable value. It's very difficult to implement in an efficient manner, and compilers are prone to many bugs in implementing it. Nearly all the value of MI can be handled with single inheritance coupled with interfaces and aggregation. What's left does not justify the weight of MI implementation.
Who is D For?
- Programmers who routinely use lint or similar code analysis tools to eliminate bugs before the code is even compiled.
- People who compile with maximum warning levels turned on and who instruct the compiler to treat warnings as errors.
- Programming managers who are forced to rely on programming style guidelines to avoid common bugs.
- Projects that need built-in testing and verification.
- Teams who write apps with a million lines of code in it.
- Programmers who think the language should provide enough features to obviate the continual necessity to manipulate pointers directly.
- Programmers who write half their application in scripting languages the other half in native langauges to speed up the bottlenecks. D has productivity features that make using such hybrid approaches unnecessary.
- D's lexical analyzer and parser are totally independent of each other and of the semantic analyzer. This means it is easy to write simple tools to manipulate D source perfectly without having to build a full compiler. It also means that source code can be transmitted in tokenized form for specialized applications.
Who D is Not For?
- Realistically, nobody is going to convert million line legacy programs into D. D, however, can connect directly to any code that exposes a C ABI interface or (to a limited extent) a C++ ABI interface.
- As a first programming language - Python or JavaScript is more suitable for beginners. D makes an excellent second language for intermediate to advanced programmers.
- Language purists. D is a practical language, and each feature of it is evaluated in that light, rather than by an ideal. For example, D has constructs and semantics that virtually eliminate the need for pointers for ordinary tasks. But pointers are still there, because sometimes the rules need to be broken. Similarly, casts are still there for those times when the typing system needs to be overridden.
Major Features of D
This section lists some of the more interesting features of D in various categories.
Object Oriented Programming
Classes
D's object oriented nature comes from classes. The inheritance model is single inheritance enhanced with interfaces. The class Object sits at the root of the inheritance hierarchy, so all classes implement a common set of functionality. Classes are instantiated by reference, and so complex code to clean up after exceptions is not required.
See the Classes page for more information.
Operator Overloading
Classes can be crafted that work with existing operators to extend the type system to support new types. An example would be creating a bignumber class and then overloading the +, -, * and / operators to enable using ordinary algebraic syntax with them.
See the Operator Overloading page for more information.
Functional Programming
Functional programming has a lot to offer in terms of encapsulation, concurrent programming, memory safety, and composition. D's support for functional style programming include:
- Pure functions
- Immutable types and data structures
- Lambda functions and closures
Productivity
Modules
Source files have a one-to-one correspondence with modules.
See the Module page for more information.
Declaration vs Definition
Functions and classes are defined once. There is no need for declarations when they are forward referenced. A module can be imported, and all its public declarations become available to the importer.
Example:
class ABC { int func() { return 7; } static int z = 7; } int q;
All members are defined in the class or struct, not separately.
class Foo { int foo(Bar c) { return c.bar; } } class Bar { int bar() { return 3; } }
Whether a D function is inlined or not is determined by the optimizer settings.
Templates
D templates offer a clean way to support generic programming while offering the power of partial specialization. Template classes and template functions are available, along with variadic template arguments and tuples.
See the Templates page for more information.
Associative Arrays
Associative arrays are arrays with an arbitrary data type as the index rather than being limited to an integer index. In essence, associated arrays are hash tables. Associative arrays make it easy to build fast, efficient, bug-free symbol tables.
See the Associative Arrays page for more information.
Documentation
Documentation has traditionally been done twice - first there are comments documenting what a function does, and then this gets rewritten into a separate html or man page. And naturally, over time, they'll tend to diverge as the code gets updated and the separate documentation doesn't. Being able to generate the requisite polished documentation directly from the comments embedded in the source will not only cut the time in half needed to prepare documentation, it will make it much easier to keep the documentation in sync with the code. Ddoc is the specification for the D documentation generator. This page was generated by Ddoc, too.
Although third party tools exist to do this for other languages. they have some serious shortcomings:
- It is difficult to parse the language correctly. Third party tools tend to parse only a subset of a language correctly, so their use will constrain the source code to that subset.
- Different compilers support different versions of a language and have different extensions to it. Third party tools have a problem matching all these variations.
- Third party tools may not be available for all the desired platforms, and they're necessarily on a different upgrade cycle from the compilers.
- Having it builtin to the compiler means it is standardized across all D implementations. Having a default one ready to go at all times means it is far more likely to be used.
Functions
D has the expected support for ordinary functions including global functions, overloaded functions, inlining of functions, member functions, virtual functions, function pointers, etc. In addition:
Nested Functions
Functions can be nested within other functions. This is highly useful for code factoring, locality, and function closure techniques.
Function Literals
Anonymous functions can be embedded directly into an expression.
Dynamic Closures
Nested functions and class member functions can be referenced with closures (also called delegates), making generic programming much easier and type safe.
In, Out, and Ref Parameters
Not only does specifying this help make functions more self-documenting, it eliminates much of the necessity for pointers without sacrificing anything, and it opens up possibilities for more compiler help in finding coding problems.
Such makes it possible for D to directly interface to a wider variety of foreign APIs. There would be no need for workarounds like "Interface Definition Languages".
Arrays
C arrays have several faults that can be corrected:
- Dimension information is not carried around with the array, and so has to be stored and passed separately. The classic example of this are the argc and argv parameters to main(int argc, char *argv[]). (In D, main is declared as main(string[] args).)
- Arrays are not first class objects. When an array is passed to a function, it is converted to a pointer, even though the prototype confusingly says it's an array. When this conversion happens, all array type information gets lost.
- C arrays cannot be resized. This means that even simple aggregates like a stack need to be constructed as a complex class.
- C arrays cannot be bounds checked, because they don't know what the array bounds are.
- Arrays are declared with the [] after the identifier. This leads to
very clumsy
syntax to declare things like a pointer to an array:
int (*array)[3];
In D, the [] for the array go on the left:
int[3]* array; // declares a pointer to an array of 3 ints long[] func(int x); // declares a function returning an array of longs
which is much simpler to understand.
D arrays come in several varieties: pointers, static arrays, dynamic arrays, and associative arrays.
See the Arrays page for more information.
Strings
String manipulation needs direct support in the language. Modern languages handle string concatenation, copying, etc., and so does D. Strings are a direct consequence of improved array handling.
Ranges
D uses the concept of a range in lieu of iterators or generators found in other languages. A range is any type that provides a common interface to a sequence of values. The purpose of a range is to allow for a simpler way to write code that works on arbitrary data, thereby making it reusable.
The most basic type of range is called an input range, which provides three methods.
struct MyRange { auto front() { // return the next value in the sequence } void popFront() { // move the front of the sequence to the next value } bool empty() { // true if the range has no more values to return } }
To understand the power of this simple interface, let's run through an example. Say we wanted to write a program that took all of the employees in a company, took out the ones younger than 40, and grouped the remaining into an array of arrays by their organization.
struct Employee { uint id; uint organization_id; string name; uint age; } struct Employees { Employee[] data; this(Employee[] employees) { data = employees; } Employee front() { return data[0]; } void popFront() { data = data[1 .. $]; } bool empty() { return data.length == 0; } }
Here the data is coming from a constructor as a simple example, but it could come from any source, like a CSV or a database.
Please note that this code should not be used in actual code, because in D, the basic dynamic array also acts as a range, so any algorithm that accepts ranges also accepts arrays. However, static arrays are not considered ranges, as the operation popFront is based on mutating the length of the range, which is impossible with static arrays. To get a range out of a static array, create a slice containing all of its elements, like so:
int[4] array = [1, 2, 3, 4]; // not a range array[]; // valid range
Now that the range is defined, we can populate it and write the filtering code.
void main() { import std.algorithm.iteration : filter, chunkBy; Employees employees = Employees([ Employee(1, 1, "George", 50), Employee(2, 3, "John", 65), Employee(3, 2, "David", 40), Employee(4, 1, "Eli", 40), Employee(5, 2, "Hal", 35) ]); auto older_employees = employees .filter!(a => a.age > 40) // lambdas in D use the => syntax .chunkBy!((a,b) => a.organization_id == b.organization_id); }
All of the algorithms in std.algorithm work with ranges to avoid the problem of rewriting common functionality for every project. std.algorithm implements sorts, filters, maps, reductions, and more.
Because our Employees struct conforms to the input range definition, it can also be used in foreach loops, which automatically detects if the value passed is an input range.
foreach(employee; employees)
{
writeln(employee);
}
which is equivalent to
for(; !employees.empty; employees.popFront())
{
writeln(employees.front);
}
Types of Ranges
The input range is just the most basic form of range, there are also
- forward ranges
- bidirectional ranges
- random access ranges
- output ranges
Each of these ranges represents a distinct way of accessing the underlying data. Or, in the case of the output range, a way to send data to another source. To learn more about each type of range, see the range primitives page in the standard library documentation.
Each of these types of ranges give you access to different algorithms in the standard library. For example, a filter can be run on an input range, but not a sort, which requires a random access range with the slice operator overload defined. The requirements for each function can be seen in the function signature in the documentation in the template constraints. See the template page and the range primitives link above for more details on template constraints.
As stated before, dynamic arrays and associative arrays in D act as ranges. Specifically, they are random access ranges, so any of the functions in std.algorithm work with these basic types.
Advanced Range Code
The following example uses input ranges and an output range to take data from stdin, take only the unique lines, sort them, and then print the result to stdout.
// Sort lines import std.stdio; import std.array; import std.algorithm; void main() { stdin .byLine(KeepTerminator.yes) .uniq .map!(a => a.idup) .array .sort .copy(stdout.lockingTextWriter());
For more examples of range based code, see the Ranges chapter in Ali Çehreli's book "Programming In D". Also, see the article Component programming with ranges by H. S. Teoh.
Resource Management
Automatic Memory Management
D memory allocation is fully garbage collected.  Garbage collection eliminates the need for tedious, error prone memory allocation tracking code. This not only means much faster development time and lower maintenance costs, but the resulting program frequently runs faster.
For a fuller discussion of this, see garbage collection.
Explicit Memory Management
Despite D being a garbage collected language, the new and delete operations can be overridden for particular classes so that a custom allocator can be used.
RAII
RAII is a modern software development technique to manage resource allocation and deallocation. D supports RAII in a controlled, predictable manner that is independent of the garbage collection cycle.
Performance
Lightweight Aggregates
D supports simple C style structs, both for compatibility with C data structures and because they're useful when the full power of classes is overkill.
Inline Assembler
Device drivers, high performance system applications, embedded systems, and specialized code sometimes need to dip into assembly language to get the job done. While D implementations are not required to implement the inline assembler, it is defined and part of the language. Most assembly code needs can be handled with it, obviating the need for separate assemblers or DLLs.
Many D implementations will also support intrinsic functions analogously to C's support of intrinsics for I/O port manipulation, direct access to special floating point operations, etc.
See the Inline Assembler page for more information.
Reliability
A modern language should do all it can to help the programmer flush out bugs in the code. Help can come in many forms; from making it easy to use more robust techniques, to compiler flagging of obviously incorrect code, to runtime checking.
Contracts
Contract Programming (invented by Dr. Bertrand Meyer) is a technique to aid in ensuring the correctness of programs. D's version of Contracts includes function preconditions, function postconditions, class invariants, and assert contracts. See Contracts for D's implementation.
Unit Tests
Unit tests can be added to a class, such that they are automatically run upon program startup. This aids in verifying, in every build, that class implementations weren't inadvertently broken. The unit tests form part of the source code for a class. Creating them becomes a natural part of the class development process, as opposed to throwing the finished code over the wall to the testing group.
Unit tests can be done in other languages, but the result is kludgy and the languages just aren't accommodating of the concept. Unit testing is a main feature of D. For library functions it works out great, serving both to guarantee that the functions actually work and to illustrate how to use the functions.
Consider the many library and application code bases out there for download on the web. How much of it comes with any verification tests at all, let alone unit testing? The usual practice is if it compiles, we assume it works. And we wonder if the warnings the compiler spits out in the process are real bugs or just nattering about nits.
Along with Contract Programming, unit testing makes D far and away the best language for writing reliable, robust systems applications. Unit testing also gives us a quick-and-dirty estimate of the quality of some unknown piece of D code dropped in our laps - if it has no unit tests and no contracts, it's unacceptable.
See the Unit Tests page for more information.
Debug Attributes and Statements
Now debug is part of the syntax of the language. The code can be enabled or disabled at compile time, without the use of macros or preprocessing commands. The debug syntax enables a consistent, portable, and understandable recognition that real source code needs to be able to generate both debug compilations and release compilations.
Exception Handling
The superior try-catch-finally model is used rather than just try-catch. There's no need to create dummy objects just to have the destructor implement the finally semantics.
Synchronization
Multithreaded programming is becoming more and more mainstream, and D provides primitives to build multithreaded programs with. Synchronization can be done at either the method or the object level.
synchronized int func() { ... }
Synchronized functions allow only one thread at a time to be executing that function.
The synchronize statement puts a mutex around a block of statements, controlling access either by object or globally.
Support for Robust Techniques
- Dynamic arrays instead of pointers
- Reference variables instead of pointers
- Reference objects instead of pointers
- Garbage collection instead of explicit memory management
- Built-in primitives for thread synchronization
- No macros to inadvertently slam code
- Inline functions instead of macros
- Vastly reduced need for pointers
- Integral type sizes are explicit
- No more uncertainty about the signed-ness of chars
- No need to duplicate declarations in source and header files.
- Explicit parsing support for adding in debug code.
Compile Time Checks
- Stronger type checking
- No empty ; for loop bodies
- Assignments do not yield boolean results
- Deprecating of obsolete APIs
Runtime Checking
- assert() expressions
- array bounds checking
- undefined case in switch exception
- out of memory exception
- In, out, and class invariant Contract Programming support
Compatibility
Operator precedence and evaluation rules
D retains C operators and their precedence rules, order of evaluation rules, and promotion rules. This avoids subtle bugs that might arise from being so used to the way C does things that one has a great deal of trouble finding bugs due to different semantics.
Direct Access to C APIs
Not only does D have data types that correspond to C types, it provides direct access to C functions. There is no need to write wrapper functions, parameter swizzlers, nor code to copy aggregate members one by one.
Support for all C data types
Making it possible to interface to any C API or existing C library code. This support includes structs, unions, enums, pointers, and all C99 types. D includes the capability to set the alignment of struct members to ensure compatibility with externally imposed data formats.
OS Exception Handling
D's exception handling mechanism will connect to the way the underlying operating system handles exceptions in an application.
Uses Existing Tools
D produces code in standard object file format, enabling the use of standard assemblers, linkers, debuggers, profilers, exe compressors, and other analyzers, as well as linking to code written in other languages.
Project Management
Versioning
D provides built-in support for generation of multiple versions of a program from the same text. It replaces the C preprocessor #if/#endif technique.
Deprecation
As code evolves over time, some old library code gets replaced with newer, better versions. The old versions must be available to support legacy code, but they can be marked as deprecated. Code that uses deprecated versions will be normally flagged as illegal, but would be allowed by a compiler switch. This will make it easy for maintenance programmers to identify any dependence on deprecated features.
Sample D Program (sieve.d)
/* Sieve of Eratosthenes prime numbers */ import std.stdio; void main() { size_t count; bool[8191] flags; writeln("10 iterations"); // using iter as a throwaway variable foreach (iter; 1 .. 11) { count = 0; flags[] = 1; foreach (index, flag; flags) { if (flag) { size_t prime = index + index + 3; size_t k = index + prime; while (k < flags.length) { flags[k] = 0; k += prime; } count += 1; } } } writefln("%d primes", count); }
NB: The expectation may be that array index x represents the number x, with i + i + 3 seeming odd at first glance. However, if one were to consider each index, it would mean that the first element would represent 0 + 0 + 3 = 3; the second element would represent 1 + 1 + 3 = 5; the third element would represent 2 + 2 + 3 = 7; and so on. So the numbers represented by the array actually go from 3 to (8190 + 8190 + 3), or 16383.


[
next
] [
prev
] [
prev-tail
] [
tail
] [
up
]
4
Unit tests
4.1
Creation of repository of unit tests
4.2
Viewing some simplicial complexes
4.3
Testing convex combination of vectors
[
next
] [
prev
] [
prev-tail
] [
front
] [
up
]


Fill the registration form
Email:
Password:
First name:
Last name:
Country:
Age:
Sign Up
Already have account?
Sign In
User with such email already exists.


Book My Show
Home
Add Movie
(current)
Add Movie
Used by Movie Hall admin
Movie Name
Poster Url
Release Date
Number of Tickets Available
Add Movie


Please enter your email
Please enter a valid email address
Please enter your password
Passwords don't match.


Two years ago I was diagnosed with moderate Rheumatoid arthritis. I suffer from severe joint pain and stiffness, crippling fatigue, and occasional bouts of depression. Since the diagnosis, I have experimented with many substances, both legal and illegal, to combat the pain and mild depression related to the disease.
In addition to Methotrexate to treat the disease, I began on traditional painkillers (Lortab), to which I quickly (and I mean scarily quickly) became addicted. After about nine months of a pathetic, non-functioning life, I broke the addiction with the assistance of Suboxone.
Luckily, I have recently discovered Kratom. I order it online about four ounces at a time. I simply put about 6 -7 grams of regular ground Kratom leaves in a big coffee cup with a teaspoon of good chai, pour boiling water over it, and steep for about three minutes. I add honey and drink up. At first I found it unbearably bitter, but have come to accept the taste as a necessary evil. I even look forward to it!
I find decent pain relief and a wonderful mood lift from this brew. I feel like my old self again; happy and relaxed. This seems to carry over, and I feel good the next day as well, if not longer! Occasionally I also get mild euphoria, which is most welcome. I never feel 'trippy'. Right after I drink it, I sometimes do some very gentle yoga stretches if I feel up to it, and about 5-10 minutes of meditation. Then I talk to my husband, watch a favorite movie, whatever I feel like doing that makes me feel good.
I do have small children, so I do not take Kratom unless they are in bed, and my husband is awake to take care of them in case they get up. I do not take so much that I feel impaired or unable to help them, but better safe than sorry where little ones are concerned. One night, my five year old did get up, and came out to the living room where I was lying on the couch (hubby sitting in a chair). She laid on my chest and we all watched TV together for awhile. It was beautiful just to hold her, and marvel at the love and connection between us - Kratom amps up my normal 'warm fuzzy' toward my family.
I drink it three times per week or so. My husband, who formerly was against pretty much any and all drugs, is totally supportive of my Kratom use. The relief and happiness it gives me, however transitory, is priceless.
Prior to Kratom, I tried marijuana for relief, but its' illegality made me uncomfortable, plus the effects aren't very conducive to family life. I felt paranoid the entire time that the kids would get up or something would happen, so that I was unable to relax and get any good out of the experience.
I plan to keep my Kratom use at this level if at all possible, never taking it more than three or so times per week. I can feel that it flips the same switch for me that Lortab did, but in a far gentler, more organic way. I am still able to function while obtaining some relief. I thank the earth for this gift, and pray that people use it responsibly. I worry that too many boneheads will abuse it and end up in the ER, thus eventually causing those who use it responsibly to suffer from the consequence.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


"recur_thursday": false,
"recur_friday": false,
"recur_saturday": true,
"duration": 2,
"duration_time_unit": "Hours"
}
Url: /api/suspension-details
Purpose: Retrieves details about an individual suspension. The fields will match the fields seen here & here.
Type: HTTP POST or HTTP GET
Json body field descriptions:
· id – The ‘suspension id’. Specifies which suspension you want to get details about (by id). Type: Number
· name – The ‘name’ field @ here. Specifies which suspension you want to get details about (by name). Type: String
Notes:
·
If ‘id’ and ‘name’ are both specified, the value
of ‘id’ will be used.
·
If making an HTTP GET request, specify the id or
name as url-encoded query string parameters.
o
Ex: /api/suspension-details?name=MySuspension
Example request POST body:
{
"id": 353
}
Example response body:
{
"id": 353,
"name": "Disk Space",
"description": "This alert suspension will suspend
alerting every Saturday & Sunday night at 9pm. The suspension will last for
2 hours. Only alerts that are associated with the 'demo' tag will be
suspended.",
"enabled": true,
"suspend_notification_only": true,
"metric_group_tags_inclusive": [
"demo"
],
"one_time": false,
"recur_sunday": true,
"recur_monday": false,
"recur_tuesday": false,
"recur_wednesday": false,
"recur_thursday": false,
"recur_friday": false,
"recur_saturday": true,
"suspend_by": "Tags",
"duration": 2,
"duration_time_unit": "Hours",
"start_date": "01/01/2015",
"start_time": "9:00 PM"
}
Url: /api/suspension-enable
Purpose: Enable or disable a suspension.
Type: HTTP POST
Json body field descriptions:
· id – The ‘suspension id’. Specifies which suspension you want to enable or disable (by id). Type: Number
· name – The ‘name’ field @ here. Specifies which suspension you want to enable or disable (by name). Type: String
· enabled – The ‘is suspension enabled?’ field @ here. Can be ‘true’ or ‘false’. Type: Boolean
Notes:
·
If ‘id’ and ‘name’ are both specified, the value
of ‘id’ will be used.
Example request POST body:
{
"id": 353,
"enabled": true
}
Url: /api/suspension-remove
Purpose: Remove (delete) a suspension.
Type: HTTP POST
Json body field descriptions:
· id – The ‘suspension id’. Specifies which suspension you want to remove (by id). Type: Number
· name – The ‘name’ field @ here. Specifies which suspension you want to remove (by name). Type: String
Notes:
·
If ‘id’ and ‘name’ are both specified, the value
of ‘id’ will be used.
Example request POST body:
{
"id": 353
}
Url: /api/suspensions-list
Purpose: Retrieves details about all of StatsAgg’s suspensions. The details provided match those of /api/suspension-details, but for all suspensions. The fields will match the fields seen here & here.
Type: HTTP GET
Example response body:
[
{
"id": 353,
"name": "Disk Space",
"description": "This alert suspension will suspend
alerting every Saturday & Sunday night at 9pm. The suspension will last for
2 hours. Only alerts that are associated with the 'demo' tag will be
suspended.",
"enabled": true,
"suspend_notification_only": true,
"metric_group_tags_inclusive": [
"demo"
],
"one_time": false,
"recur_sunday": true,
"recur_monday": false,
"recur_tuesday": false,
"recur_wednesday": false,
"recur_thursday": false,
"recur_friday": false,
"recur_saturday": true,
"suspend_by": "Tags",
"duration": 2,
"duration_time_unit": "Hours",
"start_date": "01/01/2015",
"start_time": "9:00 PM"
},
{
"id": 67,
"name": "cpu_nonprd",
"description": "Suspends non-production alerts for CPU
utilization",
"enabled": false,
"suspend_notification_only": false,
"metric_group_tags_exclusive": [
"production"
],
"one_time": false,
"suspend_notification_only": true,
"recur_sunday": true,
"recur_monday": true,
"recur_tuesday": true,
"recur_wednesday": true,
"recur_thursday": true,
"recur_friday": true,
"recur_saturday": true,
"suspend_by": "Everything",
"duration": 8,
"duration_time_unit": "Hours",
"start_date": "07/20/2014",
"start_time": "9:00 PM"
}
]
Url: /api/metric-group-create
Purpose: Create & modify metric
groups.
Type: HTTP POST
Json body field descriptions:
· id – The ‘metric group id’. Specify if you want to alter an existing metric group (as opposed to creating a new metric group). Type: Number
· name – The ‘name’ field @ here. Type: String
· description – The ‘description’ field @ here. Type: String
· match_regexes – The ‘regular expressions’ field @ here. Type: Json Array of Strings
· blacklist_regexes – The ‘blacklist regular expressions’ field @ here. Type: Json Array of Strings
· tags – The ‘tags’ field @ here. Type: Json Array of Strings
Notes:
· Modifying a metric group will replace everything about the metric group with the new fields for the metric group. This applies to ALL fields; not just those specified. For example, with this API, you can’t update the ‘description’ field without posting all the other fields.
· If ‘id’ is specified, then that tells this API that a metric group of the specified id will be modified with the specified values.
Example request POST body:
{
"name": "Application Disk Space",
"description": "Ties together all disk-space metrics that are associated with application1 and application2.",
"match_regexes": [
".*application1.*diskSpace.*",
".*application2.*diskSpace.*"
],
"blacklist_regexes": [
".*application1.*diskSpace.*temp_disk",
".*application2.*diskSpace.*temp_disk "
],
"tags": [
"application",
"demo",
"disk space"
]
}
Url: /api/metric-group-details
Purpose: Retrieves details about an individual metric group. The fields will match the fields seen here.
Type: HTTP POST or HTTP GET
Json body field descriptions:
· id – The ‘metric group id’. Specifies which metric group you want to get details about (by id). Type: Number
· name – The ‘name’ field @ here. Specifies which metric group you want to get details about (by name). Type: String
· include_metric_associations – Specifies if you want to include a list of current metric associations. Can be ‘true’ or ‘false’. Type: Boolean
Notes:
·
If ‘id’ and ‘name’ are both specified, the value
of ‘id’ will be used.
·
If making an HTTP GET request, specify the id or
name as url-encoded query string parameters.
o
Ex: /api/metric-group-details?name=MyMetricGroup
Example request POST body:
{
"id": 1130
}
Example response body:
{
"id": 1130,
"name": "Application Disk Space",
"description": "Ties together all disk-space metrics that are associated with application1 and application2.",
"match_regexes": [
".*application1.*diskSpace.*",
".*application2.*diskSpace.*"
],
"blacklist_regexes": [],
"associated_metrics": [
"someImportantPrefix.application2.diskspace.root-drive",
"someImportantPrefix.application2.diskspace.swap-drive"
],
"tags": [
"application",
"demo",
"disk space"
]
}
Url: /api/metric-group-remove
Purpose: Remove (delete) a metric group.
Type: HTTP POST
Json body field descriptions:
· id – The ‘metric group id’. Specifies which metric group you want to remove (by id). Type: Number
· name – The ‘name’ field @ here. Specifies which metric group you want to remove (by name). Type: String
Notes:
·
If ‘id’ and ‘name’ are both specified, the value
of ‘id’ will be used.
Example request POST body:
{
"id": 353
}
Url: /api/metric-groups-list
Purpose: Retrieves details about all of StatsAgg’s metric groups. The details provided match those of /api/metric-group-details, but for all metric groups. The fields will match the fields seen here.
Type: HTTP GET
Example response body:
[
{
"id": 1129,
"name": "Database Disk Space",
"description": "",
"match_regexes": [
".*database.*disk.*",
],
"blacklist_regexes": [],
"tags": [
"database",
"demo",
"disk space"
]
},
{
"id": 1130,
"name": "Application Disk Space",
"description": "Ties together all disk-space metrics that are associated with application1 and application2.",
"match_regexes": [
".*application1.*diskSpace.*",
".*application2.*diskSpace.*"
],
"blacklist_regexes": [
".*application1.*diskSpace.*temp_disk",
".*application2.*diskSpace.*temp_disk "
],
"tags": [
"application",
"demo",
"disk space"
]
}
]
Url: /api/notification-group-create
Purpose: Create & modify
notification groups.
Type: HTTP POST
Json body field descriptions:
· id – The ‘notification group id’. Specify if you want to alter an existing notification group (as opposed to creating a new notification group). Type: Number
· name – The ‘name’ field @ here. Type: String
· email_addresses – The ‘email addresses’ field @ here. Type: Json Array of Strings
Notes:
· Modifying a notification group will replace everything about the notification group with the new fields for the notification group. This applies to ALL fields; not just those specified.
· If ‘id’ is specified, then that tells this API that a notification group of the specified id will be modified with the specified values.
Example request POST body:
{
"name": "Application Team Demo",
"email_addresses": [
<EMAIL_ADDRESS><EMAIL_ADDRESS>]
}
Url: /api/notification-group-details
Purpose: Retrieves details about an individual notification group. The fields will match the fields seen here.
Type: HTTP POST or HTTP GET
Json body field descriptions:
· id – The ‘notification group id’. Specifies which notification group you want to get details about (by id). Type: Number
· name – The ‘name’ field @ here. Specifies which notification group you want to get details about (by name). Type: String
Notes:
·
If ‘id’ and ‘name’ are both specified, the value
of ‘id’ will be used.
·
If making an HTTP GET request, specify the id or
name as url-encoded query string parameters.
o
Ex: /api/notification-group-details?name=MyNotificationGroup
Example request POST body:
{
"id": 961
}
Example response body:
{
"id": 961,
"name": "Application Team",
"email_addresses": [
<EMAIL_ADDRESS><EMAIL_ADDRESS>]
}
Url: /api/notification-group-remove
Purpose: Remove (delete) a notification group.
Type: HTTP POST
Json body field descriptions:
· id – The ‘notification group id’. Specifies which notification group you want to remove (by id). Type: Number
· name – The ‘name’ field @ here. Specifies which notification group you want to remove (by name). Type: String
Notes:
·
If ‘id’ and ‘name’ are both specified, the value
of ‘id’ will be used.
Example request POST body:
{
"id": 961
}
Url: /api/notification-groups-list
Purpose: Retrieves details about all of StatsAgg’s notification groups. The details provided match those of /api/notification-group-details, but for all notification groups. The fields will match the fields seen here.
Type: HTTP GET
Example response body:
[
{
"id": 961,
"name": "Application Team",
"email_addresses": [
<EMAIL_ADDRESS><EMAIL_ADDRESS>]
},
{
"id": 962,
"name": "Database Team",
"email_addresses": [
<EMAIL_ADDRESS><EMAIL_ADDRESS>]
}
]
StatsAgg achieves high-performance by keeping nearly all of its data in memory (Java heap). As a result, the more notifications that are sent to it, the more memory is needed. ‘Notification groups’ & alerts also contribute to memory usage. Here are some tips for making sure you don’t run out of memory:
· Try to keep the number of notifications that get associated with a ‘notification group’ to a minimum.
· For alerts, keep ‘window duration’ to as narrow of a value as possible. StatsAgg only keeps the absolute minimum number of data points in memory that it needs to, but if the ‘window duration’ for an alert is set to a wide time-frame (ex—1 day), then StatsAgg will have to keep all of the data points associated with that alert’s ‘notification group’ in memory for the entire ‘window duration’.
· A 4GB heap should be enough for most moderate-use use-cases. When consuming notifications at higher rates, an 8GB heap (or more) may be needed.
o Proper memory sizing will ultimately on your specific usage pattern, so it may take some trial/error.
· StatsD timer notifications use a lot of memory compared to other notification types. This is because StatsD timer notifications, upon aggregation, are ballooned up into many separate notifications.
o Incidentally, StatsD timer notifications also use the most CPU of any notification type.
· StatsAgg has absolutely no limitations on how many notifications it will try to consume/keep in memory/aggregate/output/etc. If you create a ‘notification group’ that captures every single notification, and then create an alert (using that ‘notification group’) with a window-duration of 1000 years, StatsAgg will let you do this. Given enough data points, this will likely result in StatsAgg running out of memory & crashing.
· Send notifications less frequently. StatsAgg is very capable of handling millions of notification-series that send data infrequently. It will have more when receiving notifications at very high rates – even if the number of notification-series is very low.
· Because StatsAgg is written in Java & it keeps much of its data in-memory, heap dumps can be very useful in figuring out what specifically is causing all your memory usage. Is it an alert with an overly-wide ‘window duration’? Is it that an application is feeding notifications into StatsAgg at a rate of 1,000,000,000 notifications per second? Heap dumps are great at helping to figure this stuff out.
o Eclipse MAT is the first-choice for heap dump analysis.
o VisualVM is also good at analyzing heap dumps.
Under most circumstances, TCP is recommended over UDP for use with StatsAgg. UDP is an inherently packet-loss prone protocol, and under normal conditions, it is often possible to lose a non-trivial percentage of your packets. TCP has more guarantees on connectivity & delivery of data, so it is the preferred protocol of the author of StatsAgg. TCP & UDP notification consumption are very lightweight in StatsAgg, so there is no real performance consideration for using one or the other.
For TCP, the recommended approach is to open a connection, send the notifications, and close the connection. Leaving a connection open/hanging will tie up StatsAgg & operating system resources with no meaningful benefit.
· Java 1.8 is the minimum Java spec that StatsAgg supports.
· At the time of writing, OpenJDK Java 11 is the recommended Java Runtime Engine for StatsAgg.
· 64bit (x64) versions of Java are generally recommended over 32bit versions (x86)
· Recommended garbage collector: G1GC
o -XX:+UseG1GC
o -XX:MaxGCPauseMillis=5000
· Maximum Heap size: this heavily depends on your usage of StatsAgg.
o A good starting place is a 2.5GB heap via -Xmx2560m
o StatsAgg has been tested with maximum heap sizes as low as 512MB & as high as 48GB.
o If StatsAgg is the only application running on your server, then consider raising the maximum heap size as large as 75% of the physical memory of your server.
· Any JVM option that wasn’t explicitly mentioned somewhere in this manual is not recommended (unless you’re a Java JVM tuning expert). Tune the JVM settings at your own risk.
1) Why bother completely re-implementing the StatsD protocol?
a. When StatsAgg was first started, StatsD did not support TCP-based notification transmission, so StatsAgg sought to correct that. Also, limitations like ‘forgets Gauge values after a restart’ were a deal-breaker for many use-cases, and that would be difficult to fix in the main StatsD application.
b. If you don’t want to use StatsAgg’s implementation of StatsD, then you can send notifications to an instance of the official StatsD application & then have StatsD output its notifications to StatsAgg (which would receive them as Graphite notifications).
2) How does StatsAgg’s performance compare to StatsD?
a. In apples-to-apples performance comparisons of StatsD vs StatsAgg, StatsAgg tends to be faster by a margin of 25% to 50%. These results may vary by hardware, StatsAgg JVM options, application configurations, etc.
b. The above StatsD performance benchmark was conducted on a multi-core server. StatsD is largely a single-threaded application, and it may perform better than StatsAgg on a single-core server.
3) OpenTSDB listens for notifications on a single port for the telnet & HTTP formats. StatsAgg listens on two different ports. Why?
a. OpenTSDB implemented their TCP listener in a non-traditional way. That is to say, it is uncommon to have a single port listen for two completely different protocols. Because of the difficulty of implementation, StatsAgg currently listens for notifications on two different ports. One is a user-defined port for OpenTSDB HTTP notification input (4243 by default), and the other is a user-defined port for OpenTSDB telnet notification inputs (4242 by default).
4) "Do I need to output to Graphite/OpenTSDB/Influx/etc"?
a. No. StatsAgg doesn’t mandate that notifications be output anywhere.
5) "Can I run a multi-server deployment of StatsAgg?"
a. No. StatsAgg only works in a single-server deployment model. There are no plans to support a multi-server deployment model in the future.
b. Why not!?
i. StatsD Gauge notifications. Gauge notifications can be directly set, incremented, or decremented – and the order matters. If the order is mixed up, even slightly, then the value of the Gauge notification could end up being completely different/wrong. There is no efficient way to guarantee correct ordering with multiple servers for notifications types like this (at least not that this author could think of…).
ii. Alerting. StatsAgg’s alerting mechanism expects to be able to quickly assess what notifications are in an alerted state. If multiple servers had a partial dataset of the notification-values for a notification-key, then alert criteria couldn’t be properly evaluated.
iii. You can always just run multiple StatsAgg servers that are completely independent from each other.
6) "Performance?"
a. StatsAgg’s author has a day-job of ‘Performance Engineer’, so a lot of effort has gone into making StatsAgg perform well under heavy-load conditions. To give a general sense of overall performance, StatsAgg will use…
· around 40% CPU & ~1GB JVM Heap on a 4-core Intel i5 processor VM (running Windows 2008 R2)…
· … while consuming 100,000 Graphite-Aggregated notifications per second & a diverse set of 100,000 StatsD notifications per second. That’s 200,000 notifications per second total…
· … with 50 notification groups & 50 alerts set (window durations under 5mins).
If one were to send mostly Graphite-Passthrough notifications, then StatsAgg could potentially scale to millions of notifications per second on moderate hardware.
7) StatsAgg uses a lot of CPU after a restart! What gives?!
a. As a result, after a StatsAgg restart, it is common to have a period of high CPU utilization while notifications-keys are re-associated with ‘notification groups’. The time it takes will be proportional to (#unique-notification-keys * #notification-groups).
b. The ‘heaviness’ of the regular-expressions that are associated with the ‘notification groups’ also plays a large role in contributing to the startup time. Try to reduce the complexity of your ‘notification group’ regular-expressions whenever possible.
8) I altered a ‘notification group’ and/or alert and my alert status changed from triggered->not triggered. Why?
a. Altering a ‘notification group’ is treated as a complete refresh of everything unique about that ‘notification group’. That means that all ‘notification group’ associations are reset, and all data points that were being kept in memory because of their association with the ‘notification group’ were allowed to be cleaned up.
b. Altering an alert mandates a reset of the status of the alert. If the alert is still in a triggered state after the alteration, then it will re-alert (complete with a new notification).
9) Is any data lost as it passes through StatsAgg? Is numeric precision/accuracy maintained?
a. StatsAgg internally stores all notification-values with full numeric precision intact. Furthermore, StatsAgg does not use floating-point math operators, so you’ll never have a situation where the ‘average’ value of a set of notifications is equal to ’74.999999’ instead of ‘75’.
· The only place where precision may be lost is in the post-aggregation output of the StatsD & Graphite-Aggregator routines. Whole numbers always maintain full precision, but the fractional part (the scale of the number) is limited to 7 decimals. In such a situation, the last decimal is rounded up.
10) Will StatsAgg ever support receiving notifications in format ABC?
a. Support for various notification formats will improve over time. The only criteria is that the notification format must be open-source & capable of working within the established StatsAgg framework.
b. Feel free to suggest/request support for a particular notification format.
11) Will StatsAgg ever output to service XYZ?
a. Support for writing to other backends will likely be built into StatsAgg over time. Possible candidates include: InfluxDB, MySQL, Mongo, PostgreSQL, Apache Derby. Backends for commercial services are unlikely to be built into StatsAgg. This is because the author of StatsAgg doesn’t feel that it is appropriate to selectively implement solutions for particular closed-sourced (for-profit) companies & technologies.
1. Many errors/issues with StatsAgg will be captured in StatsAgg log file(s). The main log file is located at (tomcat-location)/logs/statsagg.log, but you may also find it useful to inspect other log files (like catalina.out).
2. StatsAgg doesn’t seem to shutdown, or litters the logs when shutting down.
a. StatsAgg attempts to shutdown gracefully, which gives each of the threads several seconds to shut down. If these threads don’t shut down after a certain period of time, they are forcibly terminated. This may result in errors in the log files, but the errors should be harmless overall. StatsAgg was built to be resilient to hard crashes.
3. The StatsAgg WebUI homepage says "StatsAgg is using its default application configuration settings. This occurs when there was an error loading the 'application.properties' configuration file."
a. As the error suggests, this usually means that the application.properties file was not created. This discusses how create/configure the application.properties file. If there was some other type of error (invalid settings, etc), then odds are good that you will find a more detail description of the error in the StatsAgg log file.
4. The StatsAgg WebUI homepage says "StatsAgg is using an ephemeral (in-memory) database. This occurs when there was an error loading the 'database.properties' configuration file."
a. As the error suggests, this usually means that the database.properties file was not created and/or improperly configured. This discusses how create/configure the database.properties file. If there was some other type of error (invalid settings, etc), then odds are good that you will find a more detail description of the error in the StatsAgg log file.
5. The StatsAgg WebUI homepage says "StatsAgg did not successfully connect to the database. Please view the StatsAgg log files for more details."
a. This most frequently occurs StatsAgg can’t connect to a MySQL database. This could be because MySQL has crashed, connectivity was lost (network is down, firewall, etc), MySQL is overload/unresponsive, etc. You will have to investigate what is wrong with the StatsAgg ßà database interaction to solve this problem. Oftentimes the StatsAgg log file is helpful in these circumstances. The StatsAgg log file is located at: (tomcat-location)/logs/statsagg.log.
b. Once the issue is discovered/fixed, it is recommended that StatsAgg be restarted.
6. Alerts/emails/WebUI are out of sync with each other. What gives?
a. While this behavior is rare, such behavior can happen when the StatsAgg database becomes unavailable for a period of time. This is exclusively a MySQL concern. The underlying reason for this behavior is that the StatsAgg application caches a lot of data to keep performance high. Cases like this are being identified/fixed, but there may be edge-cases that could lead to synchronization issues.
b. When such behavior is noticed, restart StatsAgg.
· A few StatsD features that are in the main StatsD program are missing in StatsAgg. Missing features include…
o configuring StatsAgg to be a ‘repeater’ (you can use the official StatsD program to do this and forward to StatsAgg).
o configuring StatsAgg to be in a ‘proxy cluster’ configuration (you can use the official StatsD program to do this, and forward to StatsAgg)
o outputting frequently sent notification-keys to log files
· StatsAgg is not (currently) meant for use as an incident management tool. It doesn't support alert history, event management, etc.
· StatsAgg only supports running in a single-server configuration. See the FAQs section for more information.
· StatsAgg does not currently support the Graphite 'Pickle' format (may be included in a future build).
· OpenTSDB listens for notifications on a single port for the telnet & HTTP formats. StatsAgg listens for OpenTSDB notifications on two different ports. See the FAQs section for more information.
· The OpenTSDB HTTP interface has full support for the ‘summary’ parameter, and partial support for the ‘details’ parameter. See the OpenTSDB documentation for more information.
o The ‘details’ parameter will return accurate counts for ‘failed’ & ‘success’, but the ‘errors’ field is not currently being populated.
· Do not run a build of StatsAgg that was compiled with JDK8 on a JRE7 runtime. For whatever reason (likely a compiler bug), this will result in broken functionality in StatsAgg.
Development for StatsAgg started in August 2013 by Pearson Assessments (a division of Pearson Education). It started as an internal application that was conceived as an enhanced version of StatsD, and continued to evolve after the initial design goals were achieved.
StatsAgg is developed in Java. Java was chosen because it is cross-platform, well supported, mature, and achieves relatively high performance.
StatsAgg’s design was based on the following principles:
· Keep framework usage to an absolute minimum. Only modular libraries were used (libraries that can easily be swapped out).
o No hibernate, struts, spring, play!, etc
· CPU & Memory usage must linearly scale by input notification count, notification group count, alerts count, etc. Exponential usage of CPU or Memory as a factor of any StatsAgg input was specifically avoided.
· Assume people want LOTS of unique notifications & want frequent data points for each notification.
· An admin-interface that is intuitive, but powerful.
StatsAgg is
released under that Apache 2.0 license.
http://www.apache.org/licenses/LICENSE-2.0
Lead developer/designer/architect/documenter: Jeffrey Schmidt
Associate developer: Prashant Kumar
WebUI consultants: Pasi Jouhikainen, Adam Parsons, Deepak Patnam
Architecture consultations: Pasi Jouhikainen, Adam Parsons, Michael Anderson
StatsD: etsy @ https://github.com/etsy/statsd/
Graphite: Orbitz @ http://graphite.wikidot.com/
OpenTSDB @ http://opentsdb.net/
Pearson Assessments, a division of Pearson Education: http://www.pearsonassessments.com/


Harlowe's - a boutique restaurant located in historic Old Pasadena, CA - first approached us early in their business planning to work on the design concept. The Neue Deco-inspired concept that followed helped close a deal, start a new business, and Cubicflow has since worked on the Harlowe's brand identity, web design, and much more.
Harlowe's got our full-service treatment. Logo design and branding, print collateral, completely responsive custom web site, and more. Collaboration played a vital role in creating a brand where none existed before. Every detail was considered -- when the Harlowe's team painstakingly restored the building's original wood interior, we partnered with a local and classically-trained sign painter to bring to life the signage and gold leaf window designs.


WITNESS LIST Veteran Affairs & Military Installations Committee March 15, 1999-12:00P SB 525 THIS LIST HAS NO WITNESSES. SB 526 FOR: BROOKS, CHET_COL. (SELF), AUSTIN, TX AGAINST: LITTLE, O. M. (RESERVE OFFICER'S ASSOC. AUSTIN CHAPTER & DEPT. OF TEXAS), DRPNG. SPGS, TX


--- layout: it/programit color: fill-midnight ---
Lightning talks is do on Friday and Sunday. All the wonderful talks. Let's go listening to everything. If time permits there may be space for one or two more 5 minute Lightning talks. Be ready to go!


WELCOME TO SARAJEVO
By Harvey Karten, Ph.D. Miramax Films/Channel Four Films Director: Michael Winterbottom Writer: Frank Cottrell Boyce, based on "Natasha's Story" by Michael Nicholson Cast: Stephen Dillane, Woody Harrelson, Marisa Tomei, Kerry Fox, Emily Lloyd
There are many ways for a film maker to deal with political events on the international scene. In "The Long Way Home," Mark Jonathan Harris contributed quite a revealing job using the documentary style to portray the plight of Jewish refugees following World War II. In "Peacemakers," Mimi Leder exploits Hollywood technology to fashion a story of a violent struggle between terrorists (the bad guys) and U.S. authorities (good guys). Costa-Gavras, himself an ideologue, treats revolutionaries as freedom fighters and right-wing governments as terrorists, as he does so forcefully in his most celebrated film, "Z." And in the January 1998 Miramax release "Four Days in September," Bruno Barreto involves us without taking sides in a fictionalized drama of the kidnapping of the U.S. Ambassador to Brazil by anti-government revolutionaries.
Michael Winterbottom, whose directorial credits include films as diverse as "Butterfly Kiss" (about serial killers) and "Jude," (based on the Thomas Hardy novel), takes still another tack with "Welcome to Sarajevo." Basing his film on real events much like Costa-Gavras and Harris, Winterbottom employs Frank Cottrell Boyce's screenplay about the fighting in Sarajevo during the early 1990s, highlighting the tragedy of war by focusing on the plight of children orphaned by the combat. Training his camera principally on British journalist Michael Henderson (Stephen Dillane) who covering the war, he uses a semi-documentary style to unfold a fictionalized drama as seen through Henderson's eyes.
Henderson is seen interacting with his colleagues, particularly the cynical American reporter Flynn (Woody Harrelson), who expresses his misanthropy with rhetorical questions to Henderson such as, "Your queen...I know she's the richest woman in the world, but enlighten me: what does she do?" He shares with his English buddy a disgust for the scant attention which the media afford to Bosnia, particularly when he notes that the lead story in one evening's papers deals with the separation or divorce problems of Andrew and Fergie, the Duke and Duchess of York.
Filmed on location by cinematographer Daf Hobson, Winterbottom shows us the bombed-out buildings of a city once considered among the world's prettiest, a place of parks and outdoor cafes, now reduced in many areas to rubble by fighting among ethnic factions--the Croats, the Serbs and the Muslims. "Welcome to Sarajevo" opens with black-and-white scenes of hit-and-run warfare, the rooftop snipers acting as though they were rehearsing from Jules Feiffer's prescient play "Little Murders"--at one time considered an absurdist comedy of people firing on the neighbors for no apparent reason. Though "Little Murders" gains irony by taking place in the politically stable U.S., the subtext of "Welcome to Sarajevo" is that the bloodletting is occurring in a "civilized" European city, its fighters seemingly bent on self-destruction in the name of ethnic cleansing. The human drama of the movie comes from an act of compassion: Henderson, a tough, hard-drinking Pete Hamill type who loves to banter with his American buddy about the relative merits of the UK and the U.S., is moved to an act of compassion. When the city's unhappy orphans are being evacuated to other areas of Europe such as Italy and England, he takes steps to adopt an orphanage favorite, Emira (Emira Nusevic), though such a step is illegal because Emira is already about eleven years old.
Winterbottom cleverly shows the mixture of altruism and vanity in the deeds of these two journalists. Flynn does risk his life to save a civilian who is shot by a sniper, but he is also propelled by his interest in getting recognition among his readers. As he tells Henderson, "Back home nobody's heard of Sarajevo, but they've all heard of me." For his part Henderson hopes his country will afford him a solid chunk of TV time since he is focusing sentimental stories culled from one of the city's orphanages. When social worker Nina (Marisa Tomei) sets up a busload of infants to be evacuated from Sarajevo, Henderson put into motion his plan to take Emira with him to his family in England.
Given the relative lack of interest by Americans in the Bosnian war--which ended at least temporarily in December 1995--"Welcome to Sarajevo" makes an important addition to the year's motion picture output. Dramatizations can capture the attention of millions of people far better than newsreels and talking heads programs. But somehow Winterbottom has distanced us from his material. We do not really get to know Emira, nor do we learn much about Henderson to explain his motivations. Too much of the early part of the film is taken up with a loosely structured series of scenes created to provide us with the texture of this strange confrontation. The idle chit- chat and serious drinking and smoking of the journalists is by now prosaic: we are all familiar with this stereotypical perception of the grizzled people in the profession of war correspondent.
Since we do not get to know much about the child, her mother's eventual and all-too-sudden willingness to allow the girl to stay with her new guardians in the UK does not have the impact it should.
Still, "Welcome to Sarajevo" does provide us with the feel of the place, with the strange impulses of its combat units, particular the Serbian officers who pull infants of their ethnic group off the bus which is carrying them to safety: they insist that these kids be allowed to grow up in the "Greater Serbia" which they are creating by driving out the Muslim population. Rated R. Running Time: 100 minutes. (C) 1997 Harvey Karten
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


In pictures: Spectacular scenes as Edinburgh and Glasgow hold Christmas lights switch-ons
In Glasgow, some 13,000 ticket holders filled George Square for the occasion.
by Tim McNultyThe skylines of Edinburgh and Glasgow were lit up this evening as both cities held their annual Christmas lights switch on events.
In Glasgow , some 13,000 ticket holders filled George Square for the occasion.
The festive crowd was treated to entertainment from Michelle McManus and members of the Soundsational Choir and the cast of The Steamie.
The best pictures from the Edinburgh and Glasgow Christmas lights switch-ons View gallery
Not be outdone, Edinburgh saw thousands of people fill the capital's streets to witness the switch on.
The show - hosted by Forth One Breakfast Show’s Arlene Stuart - saw performances by Little Voices Big Stars and Intercultural Youth Scotland.
Santa Clause also dropped in as the city's Christmas tree, a gift from Norway, was lit.


Before Change
// fill output window array
image_array = output_dict[
self.window.image_data_placeholder(name)]
for (i, location) in enumerate(location_array[:, 1:]):
x_, y_, z_, _x, _y, _z = location
try:
image_array[i, ...] = \
data[name][x_:_x, y_:_y, z_:_z, ...]
except ValueError:
tf.logging.fatal(
"dimensionality miss match in input volumes, "
"please specify spatial_window_size with a "
"3D tuple and make sure each element is "
"smaller than the image length in each dim.")
raise
yield output_dict
def rand_spatial_coordinates(subject_id, img_sizes, win_sizes, n_samples):
After Change
coordinates = grid_spatial_coordinates(
image_id, image_shapes, static_window_shapes, self.border_size)
n_locations = coordinates.values()[0].shape[0]
for i in range(n_locations):
// initialise output dict
output_dict = {}
for name in list(data):
assert coordinates[name].shape[0] == n_locations, \
"different number of grid samples from the input" \
"images, don"t know how to combine them in the queue"
x_, y_, z_, _x, _y, _z = coordinates[name][i, 1:]
try:
image_window = data[name][x_:_x, y_:_y, z_:_z, ...]
except ValueError:
tf.logging.fatal(
"dimensionality miss match in input volumes, "
"please specify spatial_window_size with a "
"3D tuple and make sure each element is "
"smaller than the image length in each dim.")
raise
// fill output dict with data
coordinates_key = self.window.coordinates_placeholder(name)
image_data_key = self.window.image_data_placeholder(name)
output_dict[coordinates_key] = coordinates[name][[i], ...]
output_dict[image_data_key] = image_window[np.newaxis, ...]
yield output_dict
def grid_spatial_coordinates(subject_id, img_sizes, win_sizes, border_size):
This function generates all coordinates of feasible windows, with
step sizes specified in grid_size parameter


UPL Q2 profit plunges 67% to Rs 89 cr on one-time loss
The company reported one-time loss of Rs 305 crore during the quarter against loss of Rs 57 crore in corresponding quarter previous fiscal.
Agrochemical company UPL's second quarter (July-September) consolidated net profit fell sharply by 67 percent due to one-time exceptional loss.
Profit during the quarter declined to Rs 89 crore, against Rs 270 crore reported in the same period last year.
The company reported a one-time loss of Rs 305 crore during the quarter against a loss of Rs 57 crore in corresponding quarter previous fiscal.
"Exceptional items for the period reported majorly included cost related to Agrofresh litigation in the USA and severance and integration cost due to acquisition of Arvsta group and LATAM restructuring expenses," the company said in its BSE filing.
Revenue from operations increased substantially by 83.6 percent year-on-year to Rs 7,817 crore in the quarter ended September 2019.
The company's earnings before interest, tax, depreciation and amortisation (EBITDA) grew by 83.4 percent to Rs 1,539 crore compared to year-ago, and margin was unchanged at 19.7 percent YoY.
Tax expenses were lower at Rs 66 crore due to cut in the corporate tax rate, against Rs 116 crore in the same period last year.
The stock was quoting at Rs 568.30, down Rs 37.65, or 6.21 percent on the BSE at 1520 hours IST.Get access to India's fastest growing financial subscriptions service Moneycontrol Pro for as little as Rs 599 for first year. Use the code "GETPRO". Moneycontrol Pro offers you all the information you need for wealth creation including actionable investment ideas, independent research and insights & analysis For more information, check out the Moneycontrol website or mobile app.


def _DeleteDependencies(self):
Delete VM dependencies.
self.os_disk.Delete()
self.service.Delete()
def _Create(self):
create_cmd = [AZURE_PATH,
def _DeleteDependencies(self):
Delete VM dependencies.
if self.os_disk.name:
self.os_disk.Delete()
self.service.Delete()
def _Create(self):
create_cmd = [AZURE_PATH,


Guidance
Guide for schools and local authorities to the term-on-term queries in COLLECT.
Ref: DFE-00220-2016 PDF , 195KB , 9 pages
You should use this guide while completing the school census in COLLECT , DfE’s centralised data collection and management system.
COLLECT automatically checks your data for substantial increases or decreases between the current term and the previous term and generates term-on-term queries.
More school census guidance is available.
Published: 15 September 2016
Updated: 18 January 2017
From: Department for Education


AMAZING PEOPLE ARE DOING AMAZING DESIGN IN AN AMAZING ENVIRONMENT
When you work with us, you are part of a team of committed collaboratores. all aspects pf our software development process are intergrated, interative
and agile.
Our approach unifies design, development and product managemanet to create exceptional products.
We start each project by understanding your business goals, the user's needs and the product requirements
Then we help translate them into effective and elegant solutions.
Before we sign any contract or write any line of codes our team will spend the necessary time needed to understand your product vision
The outcome of this scoping session ia proposal or high-level statement of work.
based on your requirements, we can provide a complete offering or just the piesces you need.
DESIGN
DEVELOPMENT
PRODUCT MANAGMENT
DELANI STUDIO
© 2020