Good Day , l am Dr.Titi Okonkwo., Civil Servant in the Ministry of Health. l know this proposal will come to you as asurprise because we have not met before either physically or through correspondence. I got your contact from our chamber of commerce here in Nigeria and have no doubt in your ability to handle this proposal involving huge sum of money. My father Chief Isama Okonkwo (Now Late) was the Royal Head of my community, ELEME (an oil rich town) in Nigeria. My community produces 5.8% of the total crude oil production in Nigeria and 0.5% of the Dollar value of each barrel is paid to my father as royalty by the Federal Government. My father was also the Chairman of ISAMA Special Oil Trust Fund. In his position as the Royal head and Chairman of the Oil Trust Fund, he made some money which he left for me as the only heir to inherit. The money is Eighteen Million, Five Hundred Thousand US Dollars(US$18.5). This Money originated from the accumulated royalties between 1976-1998 . Due to poor banking system in Nigeria and political instability as a result of past Military rules (1985-1999) , he deposited this Money in a Strong Room/"VAULTS" with an open beneficiary in a security company pending when he would finish arrangement to transfer it abroad . He was planning this when he died late last year of Heart Attack. Just before my father died he called my attention to the money and charged me to look for a foreigner who would assist me in the transfer/investment of the funds abroad. So l would be very grateful if you could accept to help me achieve this great objective. I promise to give you 15% of the total funds transferred to your vital bank account as compensation for your assistance. Five percent (5%)has been set aside to take care of all expenses we may incure during the transaction. To indicate your interest, contact me urgently and confidentially for more information and the roles you will play in this business. All the legal Documents concerning this Money will be sent to you as soon as we agreed together. Please I will appreciate that you send your telephone/fax numbers to enable me contact you immediately for discussions. May the almighty God bless you. Yours faithfully, Dr.Titi Okonkwo You can reach me with my private email address: " titiokonkwo@post.cz


Paolo Galeone is a Computer Engineer that always loved to write any kind of software, because he loves challenges. Recently he started to develop a passion for the Machine Learning field, in particular the Deep Learning branch.
Follow him on Twitter.


Graph Analytics
in Mobility
Created by
Dr. Andreas Hopfgartner
@
b.telligent
,
slides: https://anderl80.github.io/meetup-graph/
- Mixing graph algorithms and "classical" ML algorithms possible


Intro
My name is Manh Ellis and I enjoy Climbing, Photography and the occational bit of travel. This site is just a small showcase of my life and my personal acomplishments, but will mostly be about climbing.
I was born on February 23, 2001 in Vietnam, but I moved to Canada shortly after and have lived here ever since. I started climbing because I just couldn't find a sport that I liked, and after my mom signed me up for the Youth program at Coyote Rock Gym in Ottawa. The first year I was there I was just there for fun and games, but at the end of the year I was asked to try out for the Youth Competitive Team. For me, I wasn't sure what I was getting into and just thought it would be more fun and challenge me to climb harder. Now, six years, later I would never have imagined myself competing in International Level Events and I still wonder how I got here.


Creativity and imagination are great starting places, but hard-headed thinking and extreme attention to detail are essential to success. >>> Jet Propulsion Laboratory


Enforces whitespace style conventions.
Helps maintain a readable, consistent style in your codebase.
Seven arguments may be optionally provided:
"check-branch"
checks branching statements (if
/else
/for
/while
) are followed by whitespace."check-decl"
checks that variable declarations have whitespace around the equals token."check-operator"
checks for whitespace around operator tokens."check-module"
checks for whitespace in import & export statements."check-separator"
checks for whitespace after separator tokens (,
/;
)."check-type"
checks for whitespace before a variable type specification."check-typecast"
checks for whitespace between a typecast and its target."whitespace": [true, "check-branch", "check-operator", "check-typecast"]
{
"type": "list",
"listType": {
"type": "enum",
"enumValues": [
"check-branch",
"check-decl",
"check-operator",
"check-module",
"check-seperator",
"check-type",
"check-typecast"
]
}
}


fun toggleCamera(camera: ManagedCamera?): Unit
Simple function that sets the ManagedCamera.isPreviewing to the opposite of whatever it is, currently, and then asks the camera to update it's preview status. As the status of the camera changes, the appropriate callbacks will be called to update MainActivity labels.


Gecode::Int::Count::GqView< VX, VY, VZ, shr > Class Template Reference
[Integer propagators]
#include <count.hh>
Inherits Gecode::Int::Count::BaseView< VX, VY, VZ, shr >.
Detailed Description
template<class VX, class VY, class VZ, bool shr>
class Gecode::Int::Count::GqView< VX, VY, VZ, shr >
Propagator for counting views (greater or equal to number of equal views)
Not all combinations of views are possible. The types VX and VY must be either equal, or VY must be ConstIntView.
Requires
#include "gecode/int/count.hh"
Definition at line 449 of file count.hh.
Public Member Functions | |
| GqView (Space *home, ViewArray< VX > &x, VY y, VZ z, int c) | |
| Constructor for creation. | |
| virtual Actor * | copy (Space *home, bool share) |
| Create copy during cloning. | |
| virtual ExecStatus | propagate (Space *home, ModEventDelta med) |
| Perform propagation. | |
| virtual Reflection::ActorSpec | spec (const Space *home, Reflection::VarMap &m) const |
| Specification for this propagator. | |
Static Public Member Functions | |
| static void | post (Space *home, Reflection::VarMap &vars, const Reflection::ActorSpec &spec) |
| Post propagator according to specification. | |
| static Support::Symbol | ati (void) |
| Name of this propagator. | |
| static ExecStatus | post (Space *home, ViewArray< VX > &x, VY y, VZ z, int c) |
| Post propagator for . | |
Protected Member Functions | |
| GqView (Space *home, bool shr, GqView &p) | |
| Constructor for cloning p. |
Constructor & Destructor Documentation
template<class VX, class VY, class VZ, bool shr>
| Gecode::Int::Count::GqView< VX, VY, VZ, shr >::GqView | ( | Space * | home, | |
| bool | shr, | |||
| GqView< VX, VY, VZ, shr > & | p | |||
| ) | [inline, protected] |
template<class VX, class VY, class VZ, bool shr>
| Gecode::Int::Count::GqView< VX, VY, VZ, shr >::GqView | ( | Space * | home, | |
| ViewArray< VX > & | x, | |||
| VY | y, | |||
| VZ | z, | |||
| int | c | |||
| ) | [inline] |
Member Function Documentation
template<class VX, class VY, class VZ, bool shr>
| Actor * Gecode::Int::Count::GqView< VX, VY, VZ, shr >::copy | ( | Space * | home, | |
| bool | share | |||
| ) | [inline, virtual] |
template<class VX, class VY, class VZ, bool shr>
| ExecStatus Gecode::Int::Count::GqView< VX, VY, VZ, shr >::propagate | ( | Space * | home, | |
| ModEventDelta | med | |||
| ) | [inline, virtual] |
template<class VX, class VY, class VZ, bool shr>
| Reflection::ActorSpec Gecode::Int::Count::GqView< VX, VY, VZ, shr >::spec | ( | const Space * | home, | |
| Reflection::VarMap & | m | |||
| ) | const [inline, virtual] |
template<class VX, class VY, class VZ, bool shr>
| void Gecode::Int::Count::GqView< VX, VY, VZ, shr >::post | ( | Space * | home, | |
| Reflection::VarMap & | vars, | |||
| const Reflection::ActorSpec & | spec | |||
| ) | [inline, static] |
template<class VX, class VY, class VZ, bool shr>
| Support::Symbol Gecode::Int::Count::GqView< VX, VY, VZ, shr >::ati | ( | void | ) | [inline, static] |
template<class VX, class VY, class VZ, bool shr>
| ExecStatus Gecode::Int::Count::GqView< VX, VY, VZ, shr >::post | ( | Space * | home, | |
| ViewArray< VX > & | x, | |||
| VY | y, | |||
| VZ | z, | |||
| int | c | |||
| ) | [inline, static] |
The documentation for this class was generated from the following files:
- gecode/int/count.hh (Revision: 7285)
- gecode/int/count/view.icc (Revision: 7289)


The purpose of this project was to analyze how weather changes as you get closer To the equator . To accomplish this analysis , we first pulled data from open weather Map API to assemble a dataset on over 500 cities . The purpose of this project was to analyze how weather changes as you get closer To the equator . To accomplish this analysis , we first pulled data from open weather Map API to assemble a dataset on over 500 cities .After assembling the dataset , we used Matplotlib to plot various aspects of the weather Vs . latitude Factors we looked at included: Temperature, cloudiness , wind speed And humidity . this site provides the source data and visualizations created as part of The analysis , as well as explanations and descriptions of any trends and correlations witnessed.


San Francisco developer plans car-less community in Tempe
by Angela Gonzales, Phoenix Business JournalA San Francisco developer has selected Tempe to develop its first car-less neighborhood, a $140 million project that will house 1,000 people.
Called Culdesac, the company was founded in 2018 by former Opendoor founding team member Ryan Johnson and economic development specialist Jeff Berens .
The company has raised $10 million in venture capital funding, led by Khosla Ventures , as well as Initalized Capital, Zigg Capital, Bessemer Venture Partners and Y Combinator .
The 16-acre site at 2025 E. Apache Blvd. was chosen for the first car-free neighborhood because of the city's thriving job market, growing population and land available on a light rail station, according to a company statement.


{% extends "user/base.html" %} {% load i18n %} {% block head_title %} _("Registration successful") {% endblock %} {% block content %} {{ message }}
{% trans "Thank you for registring with Almasales you can go ahead and log in to your account by following the link below. We also sent you the confirmation email, so check it out" %}
{% trans "If you don't receive an email, please make sure you've entered the address you registered with, and check your spam folder." %}
{% trans "Return to main page" %}


The basic outline of the SAX parsing APIs is shown in Figure 1-1. To start the process, an instance of the SAXParserFactory class is used to generate an instance of the parser.
The parser wraps a SAXReader object. When the parser's parse() method is invoked, the reader invokes one of several callback methods implemented in the application. Those methods are defined by the interfaces ContentHandler, ErrorHandler, DTDHandler, and EntityResolver.
Here is a summary of the key SAX APIs:
A SAXParserFactory object creates an instance of the parser determined by the system property, javax.xml.parsers.SAXParserFactory.
The SAXParser interface defines several kinds of parse() methods. In general, you pass an XML data source and a DefaultHandler object to the parser, which processes the XML and invokes the appropriate methods in the handler object.
The SAXParser wraps a SAXReader. Typically, you do not care about that, but every once in a while you need to get hold of it using SAXParser's getXMLReader() so that you can configure it. It is the SAXReader that carries on the conversation with the SAX event handlers you define.
Not shown in the diagram, a DefaultHandler implements the ContentHandler, ErrorHandler, DTDHandler, and EntityResolver interfaces (with null methods), so you can override only the ones you are interested in.
Methods such as startDocument, endDocument, startElement, and endElement are invoked when an XML tag is recognized. This interface also defines the methods characters() and processingInstruction(), which are invoked when the parser encounters the text in an XML element or an inline processing instruction, respectively.
Methods error(), fatalError(), and warning() are invoked in response to various parsing errors. The default error handler throws an exception for fatal errors and ignores other errors (including validation errors). This is one reason you need to know something about the SAX parser, even if you are using the DOM. Sometimes, the application may be able to recover from a validation error. Other times, it may need to generate an exception. To ensure the correct handling, you will need to supply your own error handler to the parser.
Defines methods you will generally never be called upon to use. Used when processing a DTD to recognize and act on declarations for an unparsed entity.
The resolveEntity method is invoked when the parser must identify data identified by a URI. In most cases, a URI is simply a URL, which specifies the location of a document, but in some cases the document may be identified by a URN - a public identifier, or name, that is unique in the web space. The public identifier may be specified in addition to the URL. The EntityResolver can then use the public identifier instead of the URL to find the document-for example, to access a local copy of the document if one exists.
A typical application implements most of the ContentHandler methods, at a minimum. Because the default implementations of the interfaces ignore all inputs except for fatal errors, a robust implementation may also want to implement the ErrorHandler methods.
The SAX parser is defined in the packages listed in Table 1-1.
Packages |
Description |
|---|---|
org.xml.sax |
Defines the SAX interfaces. The name org.xml is the package prefix that was settled on by the group that defined the SAX API. |
org.xml.sax.ext |
Defines SAX extensions that are used for doing more sophisticated SAX processing-for example, to process a document type definition (DTD) or to see the detailed syntax for a file. |
org.xml.sax.helpers |
Contains helper classes that make it easier to use SAX-for example, by defining a default handler that has null methods for all the interfaces, so that you only need to override the ones you actually want to implement. |
javax.xml.parsers |
Defines the SAXParserFactory class, which returns the SAXParser. Also defines exception classes for reporting errors. |


This website is created for Assumption University student to choose their best dormitory. You can search dormitory and check available room of each dormitory at this website.
Tel: 02-723-2222
Location: Student Leadership & Experiential Learning Center @King David (CSLEL)
Email: auso2015@hotmail.com


I believe in making mistakes and embracing struggle. I've gone back to grad school twice, found a dream job and left it, and have three kids under the age of six! Life is not short if you keep yourself challenged.
A machine learning project that uses reinforced learning algorithms to teach an agent how to play the tower of Hanoi.
A chat bot built in the Rust programming language that uses the Project Guttenburg library. Allows the user to talk to both major and minor characters from Romeo and Juliet, Hamlet, and several more.
A final term paper that implmented Dijstra's and Primm's algorithms to find the shortest path and minimum spanning trees. I used Python and Networkx and tested the different time complexities by varying the data structures that stored the paths.


-
Interface Summary
| Interface |
Description |
| AdhocObjectFactory |
Creates objects for user-provided String class names, injecting dependencies
into them.
|
| Binder |
An object passed to a Module by the DI container during initialization, that
provides the API for the module to bind its services to the container.
|
| BindingBuilder<T> |
A binding builder that helps with fluent binding creation.
|
| ClassLoaderManager |
Maps ClassLoaders to resources.
|
| DecoratorBuilder<T> |
|
| Injector |
A facade to the Cayenne DI container.
|
| ListBuilder<T> |
A binding builder for list configurations.
|
| MapBuilder<T> |
A binding builder for map configurations.
|
| Module |
Represents a unit of configuration of the Cayenne DI container.
|
| Provider<T> |
A DI object factory interface.
|
| Scope |
Defines the scope of the instances created by the DI container.
|
| ScopeEventListener |
This interface duplicates default reflection based mechanism for receiving DI
events.
|
-
Class Summary
| Class |
Description |
| DIBootstrap |
A class that bootstraps the Cayenne DI container.
|
| Key<T> |
An object that encapsulates a key used to store and lookup DI bindings.
|
-
Exception Summary
| Exception |
Description |
| DIRuntimeException |
A runtime exception thrown on DI misconfiguration.
|
-
Annotation Types Summary
| Annotation Type |
Description |
| BeforeScopeEnd |
An annotation used by objects that want to receive scope ending events from the DI
registry.
|
| Inject |
|


FROM THE PHOTO ALBUM
- Life is like a book, just read more and more refined, more write more carefully. When read, mind open, all things have been indifferent to heart. Life is the precipitation.
- Life is likea cup of tea, let people lead a person to endless aftertastes. You again good taste, it will always have a different taste different people will hava different taste more.


you have choosen
d. cormier
Scroll
to the bottom of the page
and let Jones to smoke more weed.
When he gets stoned
you will be rewarded 1 point
made in web studio
now
j. jones
can’t fight
daniel fan’s are
getting 1 point!
Total fan’s score
35
65
share with the other fans
it’s a joke. we love and respect all fighters


Hyderabad: Onion price hits an all-time high
The sky-high prices have forced kirana stores and small retail shops against store onions.
by DECCAN CHRONICLE.Hyderabad: The price of onions is ranging from Rs 80 to Rs 100 per kg in the city as the prices rose steeply. A highest ever price of Rs 11,000 per quintal in the wholesale market was witnessed on Monday.
In the last few days, prices varied from Rs 5,000 to Rs 7,000 per quintal. But on Monday, the prices saw a major rise as it hit an all-time high. Till last week, prices were fluctuating between Rs 60 and Rs 70 per kg.
Telangana is dependent on Maharashtra for onions and the transport from the state has been low due to incessant rains. Earlier, 120 to 150 lorries per day used to transport onions but the number fell down to 80 lorries now.
The sky-high prices have forced kirana stores and small retail shops against store onions.
G Ramesh, a kirana store owner in A.S. Rao Nagar, says, “In one kg onion, if half kg is wet or of bad quality, customers fight with us. They say that we have got bad stock and are charging them for it. For this reason, since a month, I have stopped selling onions.”
People are being extremely cautious while buying onions.
Madhumita Chowdhary, a housewife, explained, “I would pick 5 kgs of onions from the super markets as it was cheap. But, of late, I buy only one kg.
Apart from the price, most of the onions smell bad. They attract fruit flies during the day and rodents at night.” The sorry state of onions has forced people reduce its use in cooking and also as raw salads.
A number of salads in India are onion-based and there is a switch to other leafy vegetables, cucumbers and beetroot.
With the price of onion continuing to sky rocket, there are vendors who are taking orders for wedding season by offering discounts. One of the reasons is clearance of stock.
Venkat Ramana, a trader in Secunderabad vegetable market, said, “I am offering discounts only for large orders of weddings. This is to keep my stocks moving.”
Vendors who have huge stocks are not seeing the desired sales and are keen to roll it out for weddings and party orders.


{% extends "header.html" %} {% block body %}
Next up, we're going to start using our example numbers data. We want to create image arrays out of our numbers data, saving them, so that we can reference them later for pattern recognition.
For this, we're going to create a "createExamples" function:
def createExamples(): numberArrayExamples = open('numArEx.txt','a') numbersWeHave = range(1,10) for eachNum in numbersWeHave: #print eachNum for furtherNum in numbersWeHave: # you could also literally add it *.1 and have it create # an actual float, but, since in the end we are going # to use it as a string, this way will work. print(str(eachNum)+'.'+str(furtherNum)) imgFilePath = 'images/numbers/'+str(eachNum)+'.'+str(furtherNum)+'.png' ei = Image.open(imgFilePath) eiar = np.array(ei) eiarl = str(eiar.tolist()) print(eiarl) lineToWrite = str(eachNum)+'::'+eiarl+'\n' numberArrayExamples.write(lineToWrite)
I left a few comments in there, but you may also want to watch the video if you're finding yourself confused on this function. The purpose of this function is to literally just append the image's array to the file so we can reference it later.
In this, we're just using a flat file as our database. This is fine for smaller data-sets, but you may want to look into working with databases, either SQLite or MySQL in the future.
SQLite is a "light" version of SQL. It is also a flat file, but is going to be a bit more efficient than using something like a .txt file.
MySQL is probably the most popular database type and api used for SQL with databases.
Running the fucntion createExamples() should now create the numArEx.txt file and populat it with number arrays. With these, we can then take new numbers, threshold if necessary, then compare the current number array with our known number patterns, making an educated guess on what the number we're looking at is.


公司简介
There are many variations of passages of Lorem Ipsum available but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use
There are many variations of passages of Lorem Ipsum available but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use
phillip morris
CEO of ecology


Creating Responses - New E-Mail
- Please provide a sender in the "From" box using the format
<EMAIL_ADDRESS>- Continue to add one or more reciepents. You could add more than one by
seperating them with a semicolon.
- Choose a subject.
- Specify the message that should be send to all reciepents. You could
make use of placeholders that will be replaced in the following manner:
You could use the following placeholders:
'$lockname' = will be replaced by the name of the lock on which the event
has been arised
'$lockphi' = ... by the serialnumber (phi) of the lock ...
'$transpondername' = ... by the name of the transponder owner ...
'$transponderphi' = ... and its phi ...
'$datetime' = ... by the time, the event has been received from the
EventMessenger
'$accessresult' ... by the result of the particular event (e.g. access
granted)
If you leave this blank, a default Message weill be send in english.
BE AWARE: Availability of placeholders is bound to the event type. A
doormonitoring event for example doesnt know anything about the transponder
owner. With that said, $transpondername and $transponderphi will be replaced
with "$dontcare" if used in an doormonitoring event.
- Please click on "SMTP Settings" to setup the mailserver you would like
to use to send the email messages.
HINT: Adding emails without a
valid smtp server configuration is not allowed.
- Add the smtp servername with respect of the following format:
'servername.domain'
- Specify a smtp server port to use.
- If the Server needs or allows SSL / TLS please check the correspondig
box.
- Check the "Use Credentials" checkbox if authentication is mandatory.
- Apply the smtp server settings to your message by clicking "OK".
- Click on "OK" in your email message dialog to finish the message setup.


{% load staticfiles %}
Stephen is a Penn State alum and an adviser to the Chairman at Alencon LLC. He has experience working with clients around the globe.


Fully Supported
Fully Supported
Partially supported. No landscape.
Currently not supported
Currently not supported
Currently not supported
This is a work in progress. If your device isn't supported, or looks misaligned, I could probably use your help to get the proper screenshots from you to make sure your device is supported and looks as good as it can. Message me on Twitter (@Polyphian) or Discord (@Polyphian#4115) so we can work together.
If you spot any bugs, or issues please contact me.
testing initial support for iPhone X and similar displays.
No landscape. Alignment may be slightly off.
initial release, for iPhone 11 & XR


Before Change
if data.get("labels", None) is not None and verbose_loss:
// forward the model to get loss
tmp = [data["fc_feats"], data["att_feats"], data["labels"], data["masks"], data["att_masks"]]
tmp = [Variable(torch.from_numpy(_), volatile=True).cuda() for _ in tmp]
fc_feats, att_feats, labels, masks, att_masks = tmp
loss = crit(model(fc_feats, att_feats, labels, att_masks), labels[:,1:], masks[:,1:]).data[0]
After Change
if data.get("labels", None) is not None and verbose_loss:
// forward the model to get loss
tmp = [data["fc_feats"], data["att_feats"], data["labels"], data["masks"], data["att_masks"]]
tmp = [torch.from_numpy(_).cuda() for _ in tmp]
fc_feats, att_feats, labels, masks, att_masks = tmp
with torch.no_grad():
loss = crit(model(fc_feats, att_feats, labels, att_masks), labels[:,1:], masks[:,1:]).item()
loss_sum = loss_sum + loss
loss_evals = loss_evals + 1
// forward the model to also get generated samples for each image


% if (dependencies) { dependencies.forEach(function (componentName) { %> <% });} %> I'm a DOM element. This is my local DOM! And this is 'greet' property: {{greet}} Change greet Computed property 'greetAll' is {{greetAll}}
I'm a DOM element. This is my local DOM!
And this is 'greet' property: {{greet}}
Change greet
Computed property 'greetAll' is {{greetAll}}


Fri Mar 24, 2006
I haven’t had anything published in a while! Here is an article I wrote entitled “Unlearning Racism” and it deals with growing up in South Africa. This is something my S.A. friends might find interesting, although I hope you guys from “die moederland” will appreciate it was written for a North American audience. It was published in a magazine entitled “Think Equity” which is distributed on the U.B.C. campus; there is a PDF version available on-line, if you’re interested follow the link and check out page 4.
[November 16, 2015: Think Equity is no longer available online. However, here is what I believe to be the first draft:]
Unlearning a Racist Pedagogy
You may think I learned a lot about racism growing up in apartheid South Africa. The truth is, I learned nothing about it. Words such as ‘discrimination’, ‘prejudice’ and ‘emancipation’ were missing from our academic lexicon. Yet, in a subtle, inexorable way, we learned everything about racism. That is to say, we were educated to be racist. Our all-white schools were perfectly self-contained euro-centric islands. In our imposed cultural isolation, we were not privy to the voice of an oppressed nation. Our sense of injustice was neutered; our perception of the world shaped by a deliberately innocuous pedagogy. In a way, we too were oppressed by the very institutions that nurtured us.
When I was very young, before I went to school, I used to play with our maid’s children outside in the sunshine. As children we had no preconceptions influencing our interactions, all we cared about was having fun. As I grew older and started school, this carelessness gave way to the expectations of society. The unspoken rules of society are hard to challenge when they are so pervasive, yet so invisible. Outside of school we learned to fear the black multitudes; on television they were portrayed as a violent and cruel race. Our parents discouraged us from walking around on the streets, where any number of (black) criminals might be lurking. In school, the “other” was somewhat romanticized. In history class we were dazzled with stories of Shaka Zulu and battles where blood dyed the rivers red. Barefooted Zulu warriors with spears and assegais marched through our dreams. We were in fear; we were in awe.
In 1994, the year I graduated from high school, South Africa instituted its first democratic government and former whites-only schools opened their doors to everybody. The first brave students were shy and awkward in their crisp new school uniforms; hardly the spear-wielding savages that had excited our collective imagination! Some welcomed them, most ignored them but none of us could understand them. We had never learned about a real people, about a living culture. We were confused and disenchanted. In time, they brought their culture, their language, their music and their joy into the classrooms. New generations of children were playing with each other again. They were having fun. Colour fell away. This was something I was never to experience. This was the new South Africa, and I was part of the old.
Was I deceived? Brainwashed? Deliberately kept in a state of fear? Ultimately, I found I could not blame a racist government, or my teachers or an erroneous ideology. I could never justify being the victim of anything, especially since the real victims never enjoyed the privileged upbringing I did. It was enough to bear the guilt of a nation sundered for so long by an embarrassingly archaic imperialistic regime. That hot shame has brought so many of us to our knees with the weight of it. I needed instead to emancipate myself and in the process grow up. It is not easy to open your heart and embrace life like a lover. So many of us allow our mental vigilance to lapse and accept the inequity of this world far too readily.
For me, part of this process involved traveling to many places and meeting many different people. I have been to places in South Africa I had previously feared to go, and found my fear unsubstantiated. I have rediscovered my country and found it to be inhabited by many humble and beautiful people both black and white. I have studied anthropology and actively sought the truth. We stagnate here in the developed world, while the developing world is painfully aware of the poignancy of this ephemeral life and lives each day in joy and pain. Too often, we draw lines of colour and in our bitterness denigrate those we fail to understand. As for my part, I strive to ensure lack of understanding will never be a hindrance to me again as I continue to learn the bittersweet lessons of life.
By Antoine H. Giraud


Micro-Frontends Broker
Pub/Sub manager for isolated components
The purpose of this library is to provide a simple and effective tool for communication within web apps composed of micro-frontends.
The standard and generally recognized solution for communication between web components, whether they are based on custom elements, or on virtual dom or other technologies, make the use of native CustomEvent, which can be subscribed within any level of visibility of the DOM .
MF-Broker tries to provide a simple and globally accessible pub / sub communication system based on CustomEvent, allowing to exchange information between the various components of a webapp and at the same time trying to limit the use of customized solutions.
The library simplifies the use of CustomEvent and does not replace them. In fact, communication can be integrated by leaving the choice of individual micro-frontends whether to exploit this library or manage the DOM events independently, thus limiting their interdependence.
The use of the library allows you to take advantage of some additional features, such as message retention which guarantees new subscriptions to receive copies of the last published message.
For micro-frontend solutions based on html framesets or iframes, where different DOM trees exist within different windows, this library uses the standard postMessage / MessageEvent web API, integrating them with communication via CustomEvent. This allows to obtain a message transmission system that involves not only the single DOM tree from where they are sent, but also the other window contexts of the frames present in the web document. Furthermore, by integrating the library in each Frame that makes up the webapp, it allows the published messages to descend every window context present, even having multiple nested iframe documents and to take advantage of other features such as retain.
By taking advantage of the communication system provided by CustomEvent or MessageEvent-based brokers, the library provides a mechanism for calling procedures defined in other contexts and which return a response. It is therefore possible to call functions that perform transformations of the data sent to them or that give a result in synchronous or asynchronous mode thanks to the use of the Promises.
/// import specific methods or classes
import { Broker, FramesetBroker, ProcedureBroker } from "mf-broker";
// ...
// or entire library
import * as mfBroker from "mf-broker";
// ...
<script type="module">
/// import specific methods or classes
import { Broker, FramesetBroker, ProcedureBroker } from "./mf-broker/esm/index.js";
// ...
// or entire library
import * as mfBroker from "./mf-broker/esm/index.js";
// ...
</script>
/// import specific methods or classes
const { Broker, FramesetBroker, ProcedureBroker } = require("mf-broker");
// ...
// or entire library
const mfBroker = require("mf-broker");
// ...
Typedoc documentation with examples can be found by clicking here.
Simple Broker Demo is visibile by clicking here. Frameset Broker Demo is visibile by clicking here.
This package is written in TypeScript and the build includes type definitions for use in other TypeScript projects.
The build of this package generates two versions:
| master | develop |
|---|---|
Generated using TypeDoc


Occasionally we have needed to modify slightly the standard include files. So, we developed a simple mechanism that allows us to create modified copies of the include files and use them instead of the standard ones. For this purpose we specify a patch file and we run a program caller Patcher which makes modified copies of include files and applies the patch.
The patcher is invoked as follows:
lib/patcher [options] Options: --help Prints this help message --verbose Prints a lot of information about what is being done --mode=xxx What tool to emulate: GNUCC - GNU CC MSVC - MS VC cl compiler --dest=xxx The destination directory. Will make one if it does not exist --patch=xxx Patch file (can be specified multiple times) --ppargs=xxx An argument to be passed to the preprocessor (can be specified multiple times) --ufile=xxx A user-include file to be patched (treated as \#include "xxx") --sfile=xxx A system-include file to be patched (treated as \#include <xxx>) --clean Remove all files in the destination directory --dumpversion Print the version name used for the current compiler All of the other arguments are passed to the preprocessor. You should pass enough arguments (e.g., include directories) so that the patcher can find the right include files to be patched.
Based on the given mode and the current version of the compiler (which the patcher can print when given the dumpversion argument) the patcher will create a subdirectory of the dest directory, such as:
/usr/home/necula/cil/include/gcc_2.95.3-5
In that file the patcher will copy the modified versions of the include files specified with the ufile and sfile options. Each of these options can be specified multiple times.
The patch file (specified with the patch option) has a format inspired by the Unix patch tool. The file has the following grammar:
<<< flags patterns === replacement >>>
The flags are a comma separated, case-sensitive, sequence of keywords or keyword = value. The following flags are supported:
The patterns can consist of several groups of lines separated by the ||| marker. Each of these group of lines is a multi-line pattern that if found in the file will be replaced with the text given at the end of the block.
The matching is space-insensitive.
All of the markers <<<, |||, === and >>> must appear at the beginning of a line but they can be followed by arbitrary text (which is ignored).
The replacement text can contain the special keyword @__pattern__@, which is substituted with the pattern that matched.


Your request to join {{ request.group.name }} has been rejected.
Your request was rejected by {{ request.changed_by.username }}, if you have any questions regarding this please contact them.


A week ago I’ve decided to learn VHDL and as an exercise, implement The game of life.
VHDL is a hardware description language. Basically, it’s a programming language used by chip designers.
This post is an introduction to VHDL.
Why learn VHDL?
I thought it’d be interesting to see what it takes to program a chip. Coming from software, I was specifically curious about the programming model and mind set. Think about it, all software eventually translates to CPU instructions. What’s underneath that?..
It’s my belief that every programmer should be familiar with the layers he relies upon.
Not every Python programmer knows C, and not every C programmer knows assembler.
Prerequisites
I’m going to assume you know nothing about hardware and a little about software.
VHDL is based on Ada so you might even find it familiar.
Intro - Booleans All The Way Down
Most hardware these days is based on boolean logic, here’s why:
- Boolean algebra has been around for ages - simple boolean operations like ‘and’, ‘or’ and ‘not’ can be composed into basic building blocks used to construct more sophisticated logic (calculators, modems, CPUs!).
- Passing boolean data is easy in hardware, you pass electricity through a wire to indicate a true state and stop passing electricity to indicate a false state.
Light bulb moment: ever wondered why integers in software are powers of two?
A CPU has a fixed amount of wires (32/64) dedicated to represent data (a.k.a word size).
Each wire represents a bit that can be true or false (1 or 0).
The binary numeral system is used to represent a number in a bunch of 1s and 0s.
Dive Into VHDL - The Life Of A Gate
Let’s start off with an implementation of an ‘and’ gate:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
|
What’s happening in the code line by line:
1-2: Include the module that exports the std_logic type which represents a bit (can be 0 or 1).
4: Define a new entity. An entity is analogous to an object in object oriented programming.
5: The entity interacts with other entities using ports. Input ports are used to receive information and output ports are used to send information.
6: Define two inputs of type std_logic.
7: Define one output of type std_logic.
11: The architecture is the implementation of the object’s behavior. Its name (arch) is redundant as only one architecture is allowed.
13: The implementation of an ‘and’ gate. Every time an input changes the output is recalculated.
By using a synthesis tool we can convert this code to a hardware schematic:
Think Parallel - A Simple Adder
We’ll implement an adder that takes two 1-bit sized inputs (x and y) and adds them to a 2-bit sized output (sum_0 and sum_1. sum_1 is the carry). The following table demonstrates the adder’s functionality:
| x | y | sum_1 | sum_0 | sum as binary | sum as int |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 | 1 |
| 1 | 1 | 1 | 0 | 10 | 2 |
Now let’s look at the code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
|
Look at lines 13-14. When does this code execute? Is line 13 executed before line 14?
The answer is: these lines execute all the time, in parallel!
A major difference between software written for CPUs and VHDL is:
VHDL is concurrent by default.
VHDL has the notion of concurrent statements vs. sequential statements.
Sequential statements can be used to implement state machines and other sequential logic.
Testing Using Sequential Code
The hardware manufacturing phase of a chip is long and expensive, therefore, VHDL programmers (often called designers) write tests (often called ‘test-benches’ or ‘simulations’).
The following test code will verify the adder’s functionality by driving different inputs and verifying the output (explanation ahead):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
|
4: Define an entity for the test. This entity has no inputs and outputs.
9-14: Repetition of the adder’s interface (VHDL isn’t very DRY)
16: Signals are wires that the test can manipulate. their type is std_logic (a bit)
19-22: A port map connects the signals to the adder’s ports. I’ve named the signals exactly as the adder’s ports.
24: The process definition. A process contains a list of sequential statements. Multiple processes run concurrently.
26-27: Signal assignments.
28: Signals have an interesting behavior where the assignment takes effect only when calling ‘wait’. This is a feature and not a bug as it allows doing atomic changes over multiple signals.
29: Assert the sum changed. In case an assertion fails, the program will stop with an error.
30 Until the end: Test the remaining cases.
We can instruct the VHDL compiler to generate a waveform of the simulation:
Note: Some VHDL statements are not synthesizable, meaning they cannot be converted to hardware and can only be used for simulations.
An example is the wait statement. A 1 nano second sleep cannot be expressed solely by logical gates.
The solution for time-aware components is connecting to a high speed clock (Implemented using a Crystal oscillator), we’ll see an example ahead.
Another Note: Not every integer addition requires a custom adder implementation.
VHDL supports integers and arithmetic operations natively.
The Game Of Life
Let’s start with a typical software-based solution:
- The board is a matrix of booleans representing cells.
- For each cycle: the next board is generated by iterating over the matrix. For each cell: count its neighbors and determine if it should live or die.
When trying to apply this design in VHDL I quickly ran into brick walls. A sequential iteration over an entire matrix is not the VHDL ‘way’. My guess is that a sequential design would generate much more logical gates and perhaps even be slower.
Software is often bound by memory and CPU.
Chip design is often bound by the amount of gates and timing issues, which surface when signals travel through large amounts of gates.
VHDL encourages you to build small components and inter-connect them where needed.
each component has its own hardware resources and works in parallel to others.
The design I came up with is the following:
- Cell - Is an entity. Connected to its neighbors via ports. The cell waits for a clock signal, counts his live neighbors and sets its alive state.
- Board - Is another entity. Contains a matrix of cells. All it does is inter-connects them.
Here’s the cell’s code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
|
3: Generics are variables that can be set upon entity instantiation. Somewhat similar to constructor arguments in object oriented languages.
4-11: The alive bits are defined as integers of one bit. In contrast to std_logic, integers support arithmetic operations, even though both are implemented as a single wire.
19: Notice the process gets an argument? A process can state a list of signals (also called a sensitivity list) that should trigger its invocation. That way, the cell will calculate its next state every time the clock changes.
20: Variables are exactly what you think they. Notice we limit the integer’s range to 8? that’s because we’ll have a maximum of 8 neighbors. VHDL will dedicate only 4 wires for that variable.
Testing A Cell
The cell’s test is very similar to the adder’s test so here’s just a snippet:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
|
The following wave form can be generated from the test:
Composing A Board From Cells
I’ll spare you of the board’s code as it contains some boilerplate. Instead, I’ll show its hardware specification:
What are you seeing:
- Each cell is a component encapsulating its logical gates.
- Each cell is connected to its neighbors through signals. The left cell is connected to the right cell’s alive signal and vice versa.
- All cells are connected to the same clock, which triggers the calculation of the next state.
Conclusions
Scalability - How does the design scale for a large amount of cells?
The software-based solution has several limits:
- Memory-wise: limited by the amount of memory.
- Speed-wise: iteration is done serially and will be directly proportional to the amount of cells, even if multiple cores are utilized.
The hardware-based solution is said to be scalable:
- Adding more cells results in adding more logical gates.
- There is no performance overhead and no arbitrary limit on the number of cells in the matrix.
How different is the mind-set?
One of the most challenging concepts in software is concurrency, it’s interesting how fundamental this topic is to hardware. Here’s how I see it:
Software - write serial code, parallelize when need to scale.
Hardware - write concurrent code, write serial code where needed.
Why bother manufacturing new chips and not re-use CPUs?
- Performance of ASICs (Application specific integrated circuits - chips created for a specific task) can be better than a CPU’s (That’s why GPUs became popular).
- Power consumption of CPUs can render them unusable for many applications.
- Price per unit can drop drastically for large amounts of ASICs (compare a GPS chip to an Intel CPU).
References
- The github repo contains the source and a makefile for compiling, running tests and generating waveforms.
- ghdl is a VHDL compiler (that even works on mac).
- gtkwave is used for visualizing simulations.
- Xilinix is used for schematic generation.


--- title: novaprova - FAQ need_jquery: yes ---
Because all the obvious names were already in use.
The name Novaprova comes from the modern Italian word prova, one of whose meanings is a test, a trial, an experiment, and the archaic Italian word nova which like the modern Italian nuova means new. Hence, new test.
Disclaimer: I don't speak Italian, but an actual Italian told me this is a silly but clear reading of the name. Also, it rhymes and it sounds vaguely like a drug.
Sure it is. All you need to do is to be able to read the debugging information that the compiler adds to the executable when you build with the -g option. The debugger reads that information, so it can't be too hard.
It turns out that almost every modern UNIX-like system uses the highly portable DWARF standard for debugging information, so there's little system-dependent code involved. The only tricky bit is reading that information for your own process, rather than for another process. Novaprova uses some runtime linker magic and the bfd library to find the on-disk executable and shared library images for the program it's linked into (including libraries opened with dlopen), and some hand-rolled code to scan the debug information.
There are other libraries that claim to do "reflection" for C++, but they all rely on magic macros or other tricks to explicitly mark classes or functions. By contrast, Novaprova's reflection can see any class, namespace, variable or function which the debugger can see, without the explicit co-operation of the code reflected.
Having real reflection is extremely useful for a test framework. At the very least it means that test functions can be discovered at runtime by trawling through all the functions in an executable and matching function names and signatures.
As far as I know, this is a feature unique to Novaprova.
Novaprova implements function mocking using a technology similar to debugger breakpoints, but working in the same process rather than in a child process.
There are several test frameworks that support mocking for C, but they all rely on the linker choosing to link against the mock function rather than the mocked one. This has major limitations.
Novaprova's runtime mocking removes all these limitations!
Novaprova's mocks can be attached to any testnode. They are installed just before the testnode or any of it's descendants is run and uninstalled after the test finishes. This means you can safely mock functions different ways in different tests, or mock functions in only some tests, or mock (almost all) functions which are used by the test framework itself. You can mock functions that are called from other functions in the same object file. You can mock static functions, as long as you know the name of the function or have it's address.
As far as I know, this is a feature unique to Novaprova.
Test parameters are a useful way of re-using test code.
Parameters in Novaprova are static char* variables with a series of pre-determined string values, which the test code or fixture setup code can use to control aspects of its behaviour. Novaprova knows which parameters apply to which test, and will run the test once for each combination of values of the parameters, setting up the parameters before each run. The result from each run is reported separately.
A test executable which uses Novaprova can be built like any other C executable. Tests are written in C, and no special build-time work is necessary (the magic all happens at runtime).
Even though Novaprova is implemented using C++ internally, it has a full C API so that tests can be implemented without a C++ compiler, just a C compiler. This is important when you have older code whose headers may or may not compile cleanly under C++.


{% include common/meta.html %}
{% include common/favicon.html %}
{% include common/fontawesome.html %}
{% include common/cookieconsent.html %}
{% include common/style.html %}
{% include common/nav.html %}
{{ content }}
{% include common/analytics.html %}
{% include common/js-bundle.html %}


- valU monthly payments option applies only to qualifying products purchased and shipped by Merchant and/or any of its affiliates, including where the "monthly payments" option is available on the product checkout page.
- valU monthly payments option is not transferable and may not be combined with other options.
- To be eligible for this option, you must be a valU customer, you must have available valU balance associated with your valU account, and you must have a good payment history on your valU purchases.
- valU monthly payments option may not be available to every customer and may not be available to you for all qualifying products.
- valU reserves the right to consider for each transaction factors including your transaction history and past products purchased using valU and the price of the qualifying product, in determining your eligibility for this option.
- Each purchase you make using valU monthly payments option will be added to your overall valU outstanding balance and will be reported to The Egyptian Credit Bureau (I-score) along with your monthly payments.
- Option is only available for qualifying products in terms of products availability for shipment and delivery.
- valU reserves the right to cancel this option at any time.
- You will be charged with the full price of the qualifying product you selected in subsequent monthly payments including interest or finance charges.
- Any interest, finance charges or fees assessed by the issuer of the payment plan to which payments are charged may still apply.
- Any applicable tax and shipping charges will be due and assessed in full as part of your monthly payment when you check out.
- You authorize valU to charge your balance with your preferred payment plan from 3 months and up to 36 months.
- You may prepay the full remaining balance of your purchase at any time, but you may not prepay a portion of the remaining balance.
- This option and your purchase, including any dispute or claim relating thereto, are subject to the terms in the Merchants terms and conditions including No Warranty, Limitation of Liabilities, Indemnity, Relationship and Notice, Disputes, Transfer of Rights and Obligations, and General Governing Law, and Warranty legal terms and conditions therein.
- Any return of a product purchased through this option, will be subject to Merchant return policy terms and the amount of any resulting refund will be available to use for buying another product with the same refund amount. This process has no impact whatsoever on your selected monthly payment plan and you’re fully liable for paying your monthly payment on due date shown on your valU mobile application.
- You may not dispose the purchased goods through any type of transaction prior full settlement of the selected monthly payments plan. Any act to dispose of the purchased goods prior full settlement may subject you to criminal consequences in case of defaults on due payments.
- In the event that you fail to pay two consecutive monthly payments, valU reserves its rights to annul this purchase and claim full settlement of due payments without prior notice or warning to you.
- You acknowledge that all purchases you do on Merchant website using valU monthly payments option are subject to valU’s terms and conditions signed by you on valU application form.
- You are fully responsible for using your valU balance on Merchant website as well as fully responsible for safeguarding the usage of your username, and OTP received on your mobile registered number from any third parties &/or breaches, which, in the event that this happens, valU bears no responsibility.
- You fully and unconditionally agree to the right of valU to collect, preserve and possess all the information, data and documents submitted by you for use in legally permissible purposes.
- You agree expressly and unconditionally to deal through electronic means and media (including e-mail messages), and that such means and media are valid and with full legal effect.
- Products identified in the Consumer Finance Law no. 18 of 2020 only shall be permissible.
- valU monthly payments option applies only to qualifying products purchased and shipped by Merchant and/or any of its affiliates, including where the "monthly payments" option is available on the product checkout page.
- valU monthly payments option is not transferable and may not be combined with other options.
- To be eligible for this option, you must be a valU customer, you must have available valU balance associated with your valU account, and you must have a good payment history on your valU purchases.
- valU monthly payments option may not be available to every customer and may not be available to you for all qualifying products.
- valU reserves the right to consider for each transaction factors including your transaction history and past products purchased using valU and the price of the qualifying product, in determining your eligibility for this option.
- Each purchase you make using valU monthly payments option will be added to your overall valU outstanding balance and will be reported to The Egyptian Credit Bureau (I-score) along with your monthly payments.
- Option is only available for qualifying products in terms of products availability for shipment and delivery.
- valU reserves the right to cancel this option at any time.
- You will be charged with the full price of the qualifying product you selected in subsequent monthly payments including interest or finance charges.
- Any interest, finance charges or fees assessed by the issuer of the payment plan to which payments are charged may still apply.
- Any applicable tax and shipping charges will be due and assessed in full as part of your monthly payment when you check out.
- You authorize valU to charge your balance with your preferred payment plan from 3 months and up to 36 months.
- You may prepay the full remaining balance of your purchase at any time, but you may not prepay a portion of the remaining balance.
- This option and your purchase, including any dispute or claim relating thereto, are subject to the terms in the Merchants terms and conditions including No Warranty, Limitation of Liabilities, Indemnity, Relationship and Notice, Disputes, Transfer of Rights and Obligations, and General Governing Law, and Warranty legal terms and conditions therein.
- Any return of a product purchased through this option, will be subject to Merchant return policy terms and the amount of any resulting refund will be available to use for buying another product with the same refund amount. This process has no impact whatsoever on your selected monthly payment plan and you’re fully liable for paying your monthly payment on due date shown on your valU mobile application.
- You may not dispose the purchased goods through any type of transaction prior full settlement of the selected monthly payments plan. Any act to dispose of the purchased goods prior full settlement may subject you to criminal consequences in case of defaults on due payments.
- In the event that you fail to pay two consecutive monthly payments, valU reserves its rights to annul this purchase and claim full settlement of due payments without prior notice or warning to you.
- You acknowledge that all purchases you do on Merchant website using valU monthly payments option are subject to valU’s terms and conditions signed by you on valU application form.
- You are fully responsible for using your valU balance on Merchant website as well as fully responsible for safeguarding the usage of your username, and OTP received on your mobile registered number from any third parties &/or breaches, which, in the event that this happens, valU bears no responsibility.
- You fully and unconditionally agree to the right of valU to collect, preserve and possess all the information, data and documents submitted by you for use in legally permissible purposes.
- You agree expressly and unconditionally to deal through electronic means and media (including e-mail messages), and that such means and media are valid and with full legal effect.
- Products identified in the Consumer Finance Law no. 18 of 2020 only shall be permissible.


Symlinks are useful in a variety of ways.
There exists the potential for SUID symlink privesc
and much more
Symlinks:
Symlinks or symbolic links are a very useful tool in Linux. They allow us to make a "shortcut" (in windows terms) to a file or folder. For example
ln -s /etc/passwd /tmp/passwd_file
This creates a link called /tmp/passwd_file to /etc/passwd, so now whenever /tmp/passwd_file is opened it will open /etc/passwd. Although symlinks can be infinately useful, they are quite easily exploitable. Lets say for example Joe attacker is feeling particularly sneaky, Joe knows root uses '.' in his path, and that all users can post technical problems to the admin into a directory /usr/problems/. The attack is below, and the full description will follow:
1) $ ln -s /root/.rhosts /tmp/root-rhost
2) $ stat /tmp/root-rhost
3) ...stat: cannot stat /tmp/root-rhost
4) $ cat /usr/problems/ls
5) ...#!/bin/bash
6) ...if [ ! -e /tmp/root-rhost ] ; then
7) ......echo "+ +" >>/tmp/root-rhost
8) ...fi
I will explain the above attack in detail:
Lines 1, 2 & 3: The attacker creates symbolic link from /tmp/root-rhost to /root/.rhosts, and uses stat to see if the file existed, the output on line three indicates that /root/.rhosts does not exist (the admin removed /root/.rhosts because he saw this file as a security threat - this is what Joe wants)
Line 4 to 8: He then creates a bash script called ls (which will be run instead of /bin/ls, because '.' is in his path first, when he wants to list the contents of /usr/problems/). This program tests if /tmp/root-rhost exists, because it is a symbolic link pointing to /root/.rhosts (which does not exist) it will return that /root/.rhosts does not exist, so it will then echo "+ +" into /tmp/root-rhost, which will be forwarded into the file /root/.rhosts! This will mean that root will have a passwordless login over any login that supports and allows rhosts authentication (e.g. rlogin and ssh). The trap is now set, he just has to wait!
Cron jobs with symlinks can also be used to an attackers advantage, for example:
The 'sales' group in businesscorp.com have a folder to post their documents for the whole group to read and write to, unfortunately the users keep forgetting to add group write permissions to their documents, so the admin developed a script that will change the files in the sales folder to the group sales, and set group writeable permissions, this script is run periodically through a cron job, the script looks like the below.
1) #!/bin/bash
2) chgrp -R sales /usr/export/sales
3) chmod -R g+w /usr/export/sales
If someone sneaky in sales decided to make two symlinks to /etc/passwd and /etc/shadow, the cron job would follow the symlinks and set write permissions for the group sales on /etc/passwd and /etc/shadow. From here the attacker can change any password s/he wants.


Customer
Welcome!
Customer
Edit Profile
Logout
Ride Now!
History
Truck Type
Minivan
Sport utility vehicle
Canopy express
Pickup truck
Panel truck
Cab-forward
Tow truck
Panel van
Sedan delivery
Source
Destination
Search
Available Trucks
#
Truck
Vehicle Type
Vehicle Name
Mileage
1
admin
Sedan
Maruti Swift
24.00
Book Ride
Summary of undertaken rides
#
Truck
Date
Source
Destination
Up Time
Down Time
Distance
Amount
1
admin
01-JAN-16
Esplanade
Ultadanga
02:00
04:00
14.02
256.00
Menu 2
Some content in menu 2.


Numbers and Math!
For your consideration:
A javaScript calculator that sort of works
sometimes.
0
Ooops!
÷
x
7
8
9
+
4
5
6
-
1
2
3
=
0
.


| InstInnovation {sandwich} | R Documentation |
Firm-level panel data on innovation and institutional ownership from 1991 to 1999 over 803 firms. The observations refer to different firms over different years.
data("InstInnovation")
A data frame containing 6208 observations on 25 variables.
factor. Company names.
numeric. Sales (in millions of dollars).
numeric. Constant inverse Lerner index.
numeric. Varying inverse Lerner index.
numeric. Net stock of property, plant, and equipment.
integer. Future cite-weighted patents.
numeric. Presample average of cite-weighted patents.
factor. Indicates zero precites.
integer. Granted patents.
factor. Indicates a zero R&D stock.
numeric. R&D stock (in millions of dollars).
numeric. Employment (in 1000s).
factor. Membership of firms in the S&P500 index.
numeric. Tobin's q.
numeric. Stock market value.
numeric. Proportion of stock owned by institutions.
factor. Four-digit industry code.
factor. Estimation period.
numeric. Share of the largest institution.
numeric. Share of "quasi-indexed" institutional owners.
numeric. Share of "non-quasi-indexed" institutional owners.
numeric. Share of "transient" institutional owners.
numeric. Share of "dedicated" institutional owners.
numeric. Varying inverse Lerner index in the firm's four-digit industry.
factor. Subsample for the replication of columns 1–5 from Table 4 in Aghion et al. (2013).
Aghion et al. (2013) combine several firm level panel datasets (e.g., USPTO, SEC and Compustat) to examine the role of institutional investors in the governance of innovation. Their baseline to model innovation is the Poisson model, but they also consider negative binomial models. Berger et al. (2017) argue that nonlinearities in the innovation process emerge in case that the first innovation is especially hard to obtain in comparison to succeeding innovations. Then, hurdle models offer a useful way that allows for a distinction between these two processes. Berger et al. (2017) show that an extended analysis with negative binomial hurdle models differs materially from the outcomes of the single-equation Poisson approach of Aghion et al. (2013).
Institutional ownership (institutions) is defined as the proportion of stock owney by institutions. According to Aghion et al. (2013), an institutional owner is defined as an institution that files a Form 13-F with the Securities and Exchange Commission (SEC).
Future cite-weighted patents (cites) are used as a proxy for innovation. They are calculated using ultimately granted patent, dated by year of application, and weight these by future citations through 2002 (see Aghion et al. (2013)).
The presample average of cite-weighted patents (precites) is used by Aghion et al. (2013) as a proxy for unobserved heterogeneity, employing the "presample mean scaling" method of Blundell et al. (1999).
The inverse Lerner index in the firm's three-digit industry is used as a time-varying measure for product market competition (competition), where the Lerner is calculated as the median gross margin from the entire Compustat database in the firm's three-digit industry (see Aghion et al. (2013)). A time-invariant measure for competition (acompetition) is constructed by averaging the Lerner over the sample period.
The classification of institutions into "quasiindexed", "transient" and "dedicated" follows Bushee (1998) and distinguishes between institutional investors based on their type of investing. Quasiindexed institutions are do not trade much and are widely diversified, dedicated institution do not trade much and have more concentrated holdings, and transient institutions often trade and have diversified holdings (see Aghion et al. (2013) and Bushee (1998)).
Data and online appendix of Aghion et al. (2013).
Aghion P, Van Reenen J, Zingales L (2013). “Innovation and Institutional Ownership.” The American Economic Review, 103(1), 277–304. doi: 10.1257/aer.103.1.277
Berger S, Stocker H, Zeileis A (2017). “Innovation and Institutional Ownership Revisited: An Empirical Investigation with Count Data Models.” Empirical Economics, 52(4), 1675–1688. doi: 10.1007/s00181-016-1118-0
Blundell R, Griffith R, Van Reenen J (1999). “Market Share, Market Value and Innovation in a Panel of British Manufacturing Firms.” Review of Economic Studies, 66(3), 529–554.
Bushee B (1998). “The Influence of Institutional Investors on Myopic R&D Investment Behavior.” Accounting Review, 73(3), 655–679.
## Poisson models from Table I in Aghion et al. (2013) ## load data set data("InstInnovation", package = "sandwich") ## log-scale variable InstInnovation$lograndd <- log(InstInnovation$randd) InstInnovation$lograndd[InstInnovation$lograndd == -Inf] <- 0 ## regression formulas f1 <- cites ~ institutions + log(capital/employment) + log(sales) + industry + year f2 <- cites ~ institutions + log(capital/employment) + log(sales) + industry + year + lograndd + drandd f3 <- cites ~ institutions + log(capital/employment) + log(sales) + industry + year + lograndd + drandd + dprecites + log(precites) ## Poisson models tab_I_3_pois <- glm(f1, data = InstInnovation, family = poisson) tab_I_4_pois <- glm(f2, data = InstInnovation, family = poisson) tab_I_5_pois <- glm(f3, data = InstInnovation, family = poisson) ## one-way clustered covariances vCL_I_3 <- vcovCL(tab_I_3_pois, cluster = ~ company) vCL_I_4 <- vcovCL(tab_I_4_pois, cluster = ~ company) vCL_I_5 <- vcovCL(tab_I_5_pois, cluster = ~ company) ## replication of columns 3 to 5 from Table I in Aghion et al. (2013) cbind(coef(tab_I_3_pois), sqrt(diag(vCL_I_3)))[2:4, ] cbind(coef(tab_I_4_pois), sqrt(diag(vCL_I_4)))[c(2:4, 148), ] cbind(coef(tab_I_5_pois), sqrt(diag(vCL_I_5)))[c(2:4, 148), ]


SpiceJet, Gulf Air sign MoU to explore codeshare and coordinated engineering services
“SpiceJet and Gulf Air will look at collaborating."
by PTISpiceJet and Bahrain’s national carrier Gulf Air on Wednesday signed a Memorandum of Understanding to explore possibilities regarding interline and codeshare agreement, coordinated cargo services, engineering services and pilot training. The MoU was signed by Ajay Singh, chairman and managing director, SpiceJet, and Kreimir Kucko, chief executive officer, Gulf Air, in New Delhi.
“SpiceJet and Gulf Air will look at collaborating in the field of pilot training to nurture talent in order to deliver the finest resources for both the airlines. The airlines will also engage and collaborate to enhance their respective cargo and engineering services,” the Indian budget carrier said in a statement.


Hello everybody. My name is Michelangelo and I'm trying to mount, set and configure the whole oem system. Now I encountered some troubles. The basestation is a Raspberry pi with rfm12pi module. This module is placed up on the gpio pin . EMONTX is 3 version with CT current sensors.
I'm a beginner. When I set up the rfm module as written in the wiki, the service rfm12piphp does not exists so I cannot continue the procedure. I would know how resolve this.
Re: First open energy monitor project
The wiki does need updating maybe as the "rfm12piphp" is rarely used, if at all now.
However the idea is the same for which ever way you are communicating with the RFM2Pi board, the common method currently is emonHub.
To stop emonHub use
sudo service emonhub stop
and to start again
sudo service emonhub start
Paul
Re: First open energy monitor project
Hi Paul and thanks now I can start the service. When the module is attached the OS goes very slow, when the module isn't in place it works fine.
In order to send - acquire data, can I directly communicate with emontx using the miniport usb ?
Re: First open energy monitor project
Do you mean the USB socket on the emonTX? - No, that is for power only.
Re: First open energy monitor project
We maybe able to help you some more if you tell us more about what you are doing.
Normally you can put the SD card in plug on the rfm2pi and it all works. You will need to set up some details in emonhub.conf either before you insert the SD card to the Pi or after the Pi has booted up via ssh or keyboard and monitor.
I'm not sure why you were following the steps in the wiki, were you trying to upload a different sketch to the one pre-loaded?
You should not need to start the emonHub service unless you stop it as it should start automatically at boot up.
You can use a FTDI programmer to connect to the emonTx v3's 6pin FTDI header from the Pi's usb for debugging or you can create a direct-serial connection in place of the RFM2Pi module if you want the emonTx permanently connected to the Pi.
However if you are having "serial port issue" as your "When the module is attached the OS goes very slow, when the module isn't in place it works fine." comment may suggest, then using the same serial port to connect directly with the Pi may yield the same result.
Paul
Re: First open energy monitor project
I have to monitor home energy consumption and temperature so that some instruments power off if consumption or temperature are higher than a value. So that it will be done a statistical analysis of the effective energy and temperaure spent in time to manage every situations.
The raspian os (debian in this case) lags every time the rfm module is connected to gpio. I have not upload any sketches, I have only installed arduino and downloaded the rfm firmware on the sd of raspberry. Firstly I will try a wireless connection between emontx and radsperrypi. Is it posible upload arduino sketches wirelessly on the arduino emontx? I know it is possible directly using usb to serial converter.
Re: First open energy monitor project
Are you using a shop bought SD card, downloaded image or did you build yourself? if the latter did you follow a guide? if so which?
How are you experiencing " lag" ? does it just taking longer to do a specific task or are you measuring the speed somehow?
The Arduino IDE is a "graphical interface" and won't run correctly in read-only mode, are you running read-only? are you running headless (via ssh) or using keyboard and screen? from the command line or xstart?
No, not wirelessly.
Paul
Re: First open energy monitor project
I'm using the sd card with original raspbian image downloaded from main raspberry site and mounted. So I had to configure rfmv2 as explained in this guide: http://wiki.openenergymonitor.org/index.php?title=RFM12Pi_V2
I already tried to use pre built image but It were impossible modify system configuration files like keyboard, neither with super user root privileges. Now , using the original image, all work fine without rfm module.
The lag consists of a slow time reaction by the computer, some inconveniences like black screen sometimes , the cursor don't respond, the system don't respond to keyboard tastes. I'm running using keyboard and screen using lxterminal.
Can I only use a FTDI Serial TTL-232 USB Cable like this:http://www.adafruit.com/products/70 for pc connection or I need the serial to uart programmer ?
Re: First open energy monitor project
Unable to post full reply in the thread so I have started another thread First open energy monitor project (PART 2)
Paul


For most types of debt the rate is usually 8%.
To calculate this, use the steps below.
-
Work out the yearly interest: take the amount you’re claiming and multiply it by 0.08 (which is 8%).
-
Work out the daily interest: divide your yearly interest from step 1 by 365 (the number of days in a year).
-
Work out the total amount of interest: multiply the daily interest from step 2 by the number of days the debt has been overdue.
Example
If you were owed £1,000:
- the annual interest would be £80 (1000 x 0.08 = 80)
- you’d divide £80 by 365 to get the daily interest: about 22p a day (80 / 365 = 0.22)
- after 50 days this would be £11 (50 x 0.22 = 11)


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/from.20tactics.20to.20terms.html ---
Even though I'm beginning to understand a bit of the meta
-world, I still don't fully comprehend the tactic monad. For example: is it possible to extract a concrete term from a begin ... end
-block?
Ok, I found format_result
in Ed's recent docs on meta
.
The problem is that I don't see any output anywhere, when I plug it into some begin ... end
block.
You'll need to trace
it?
Hmm. Good idea. But trace tactic.format_result
gives the error
failed to synthesize type class instance for ⊢ has_to_tactic_format (tactic format)
sounds ironic
trace_state
usually prints a trace.
@Johan Commelin See tactic.trace_result
Last updated: Apr 24 2020 at 19:02 UTC