Uefa confirm Ireland’s Euro 2020 playoff and tournament seedings
McCarthy’s side head for Slovakia while qualification could see a potential group of death
by Ruaidhrí CrokeUefa have confirmed that Ireland’s Euro 2020 playoff semi-final will take place away to Slovakia on Thursday, March 26th.
While it looked certain that Ireland would be facing the Slovaks, there was still the chance that Uefa may change the playoff paths and bump Ireland from Path B up to Path A, as they have the power to do through their Emergency Panel.
However, they have now confirmed that Ireland, Northern Ireland, Bosnia and Herzegovina and Slovakia will make up the Path B playoffs.
In the other semi-final on March 26th, Northern Ireland will travel to take on Bosnia and Herzegovina with the winner of that match facing the winner of Ireland and Slovakia in the final.
Who gets to host that final will be decided at Friday’s playoff draw in Nyon meaning that Ireland may be facing a trip to Bosnia or Belfast or indeed a home tie in Dublin five days after the semi-final on March 31st.
Slovakia have until December 20th to decide on the venue for their meeting with Ireland. Since 2015 they have played every competitive match in Trnava – 47km from the capital Bratislava – but they recently played a friendly at the newly-renovated stadium in the capital, meaning they may decide to host Ireland there.
The rest of the playoff fixtures will be confirmed at the draw on Friday as one of Bulgaria, Israel, Romania or Hungary will have to be bumped up to Path A.
Meanwhile, the seeding for the final tournament draw – which takes place on Saturday November 30th – has also been announced.
As a host nation Ireland have already been assigned to Group E alongside Spain and will be joined by one of France, Poland, Switzerland or Croatia as well as one of Portugal, Turkey, Austria, Sweden or Czech Republic.
Dauntingly enough that means that, should Ireland negotiate the playoffs and qualify, they could face a group of the current world champions in France, the defending European champions in Portugal and Spain who won back-to-back European Championships in 2008 and 2012, beating Ireland 4-0 in the group stages in the latter.
Due to the fact that Ireland have to go through the playoffs to reach the main tournament, it has also been confirmed that the group stage meeting with Spain, should Ireland qualify, will take place in Bilbao with McCarthy’s men playing the other two group games in Dublin.
Exact fixture details – including when those potential Ireland matches in Dublin will take place – will be confirmed at the finals draw on Saturday week.
Euro 2020 playoff round fixtures:
Path A
Iceland v Hungary/Romania
Bulgaria/Israel v Israel/Hungary
Path B
Bosnia and Herzegovina v Northern Ireland
Slovakia vs. Republic of Ireland
Path C
Scotland v Bulgaria/Israel/Romania/Hungary
Norway v Serbia
Path D
Georgia v Belarus
North Macedonia v Kosovo
Euro 2020 Pots:
Pot 1
Belgium
Italy (hosts)
England (hosts)
Germany (hosts)
Spain (hosts)
Ukraine
Pot 2
France
Poland
Switzerland
Croatia
Netherlands (hosts)
Russia (hosts)
Pot 3
Portugal
Turkey
Denmark (hosts)
Austria
Sweden
Czech Republic
Pot 4
Wales
Finland
Winner playoff Path A
Winner playoff Path B (potentially Ireland or Northern Ireland)
Winner playoff Path C
Winner playoff Path D


TData
- Type of data the programs instructions operate on.
TOutput
- The type of the program output(s).
public class Program<TData,TOutput extends Output<TData>> implements Module
An LGP program that is composed of instructions that operate on registers.
| Constructor and Description |
|---|
Program()
An LGP program that is composed of instructions that operate on registers.
|
| Modifier and Type | Method and Description |
|---|---|
Program<TData,TOutput> |
copy()
Creates a clone of the given program.
|
void |
execute()
Executes the program.
|
void |
findEffectiveProgram()
Provides a way to find an LGP programs effective set of instructions.
|
java.util.List<nz.co.jedsimson.lgp.core.program.instructions.Instruction> |
getEffectiveInstructions()
The instructions in this
class Program that are effective. |
double |
getFitness()
Represents the fitness of this
class Program . |
java.util.List<nz.co.jedsimson.lgp.core.program.instructions.Instruction> |
getInstructions()
The instructions in this
class Program . |
java.util.List<java.lang.Integer> |
getOutputRegisterIndices()
The indices of register(s) that the program uses as output.
|
RegisterSet<TData> |
getRegisters()
The set of registers that this
class Program runs against. |
TOutput |
output()
Retrieves the program output.
|
void |
setEffectiveInstructions(java.util.List<nz.co.jedsimson.lgp.core.program.instructions.Instruction> p)
The instructions in this
class Program that are effective. |
void |
setFitness(double p)
Represents the fitness of this
class Program . |
void |
setInstructions(java.util.List<nz.co.jedsimson.lgp.core.program.instructions.Instruction> p)
The instructions in this
class Program . |
getInformation
public Program()
An LGP program that is composed of instructions that operate on registers.
public double getFitness()
Represents the fitness of this class Program
.
When a class Program
is first initialised, the value will be FitnessFunctions.UNDEFINED_FITNESS.
class Program
,
class Program
public void setFitness(double p)
Represents the fitness of this class Program
.
When a class Program
is first initialised, the value will be FitnessFunctions.UNDEFINED_FITNESS.
class Program
,
class Program
@NotNull public java.util.List<nz.co.jedsimson.lgp.core.program.instructions.Instruction> getEffectiveInstructions()
The instructions in this class Program
that are effective.
By default, this list is empty. It is expected that a call to Program.findEffectiveProgram
would populate this list.
class Program
,
Program.findEffectiveProgram
public void setEffectiveInstructions(@NotNull java.util.List<nz.co.jedsimson.lgp.core.program.instructions.Instruction> p)
The instructions in this class Program
that are effective.
By default, this list is empty. It is expected that a call to Program.findEffectiveProgram
would populate this list.
class Program
,
Program.findEffectiveProgram
@NotNull public java.util.List<nz.co.jedsimson.lgp.core.program.instructions.Instruction> getInstructions()
The instructions in this class Program
.
This collection can be modified to modify the behaviour of this class Program
.
class Program
,
class Program
public void setInstructions(@NotNull java.util.List<nz.co.jedsimson.lgp.core.program.instructions.Instruction> p)
The instructions in this class Program
.
This collection can be modified to modify the behaviour of this class Program
.
class Program
,
class Program
@NotNull public RegisterSet<TData> getRegisters()
The set of registers that this class Program
runs against.
class Program
@NotNull public java.util.List<java.lang.Integer> getOutputRegisterIndices()
The indices of register(s) that the program uses as output.
@NotNull public TOutput output()
Retrieves the program output.
public void execute()
Executes the program.
@NotNull public Program<TData,TOutput> copy()
Creates a clone of the given program.
When copying a program, a deep copy should be provided, to ensure that when a program is modified, it does not effect the state of other programs.
public void findEffectiveProgram()
Provides a way to find an LGP programs effective set of instructions.


Ezekiel 42:9
And from under these chambers was the entry on the east side, as one goeth into them from the utter court.


Basic polymer-gridstack demo
DIV ONE
DIV TWO
DIV THREE NO RESIZE
DIV FOUR
DIV FIVE
DIV SIX
DIV SEVEN
DIV EIGHT
DIV NINE
DIV TEN
DIV ELEVEN


{% extends "base.html" %} {% block content %}
This is a mini blog site project, developed by me, Md. Asif Haider, as my first hands on server side programming, using Flask and Bootstrap. I am very much excited and can't just wait to see the wonderful posts from you guys! Let's explore the site, post your write-ups and send feedback about the site!


Edit User: {{ username }}
Enter new values for password and full name fields, otherwise keep field blank to keep current values.
username:
password:
full name:
username:
Delete {{ username }} ?:


SECTION: 250-Configuration TITLE: 200logging QUESTION: How do I configure logging?
Jetty contains logging mechanisms for requests, servlet contexts, container implementation and support for logging mechanisms including log4j, commons logging, Java 1.4 and a Jetty native logger.
The configuration of these logging mechanisms is described in the Jetty Tutorial.


Loading data...
{{resultsSectionTitle}}
Loading data...
No repos found containing the search term '{{searchText}}'.
Forked from {{project.ForkedFrom}}
{{project.Description}}
{{project.Stars}}stars
{{project.Forks}}forks


What is the difference between Public IP and Private IP and Elastic IP?
Public IP is an IP that is accessable from a public network. Private IP is an IP that is not accessible from a public network. Elastic IP is similar to public IP but can be attached and detached to cloud resources. For example, Elastic IP can be mapped from one EC2 server to another EC2 server in AWS.
What is load balancing?
Load balacing is a way of distrubuting incoming traffic to various servers instead of all requests going to same server.
What is auto scaling?
Auto scaling is the process of increasing or decreasing the number of servers (resources) based on incoming load.
What is CIDR Block?
Classless Inter-Domain Routing (CIDR) block basically is a method for allocating IP addresses and IP routing. When you create a network or route table, you need to specify what range are you working in. "<IP_ADDRESS>" means that it will match to any IP address.
What is the difference between Virtualization and Cloud?
Virtualization separates the hardware from physical machine to create multiple virtual machines on the same server while cloud gets build using multiple virtual infrastructures which combines the multiple virtualize applications/software/servers to create one instance for each application or software or server for users.
What is CORS in cloud?
Cross-origin resource sharing (CORS) is a standard for accessing web resources on different domains. CORS allows web scripts to interact more openly with content outside of the original domain, leading to better integration between web services.
What is CDN?
A content delivery network (CDN) refers to a geographically distributed group of servers which work together to provide fast delivery of Internet content. CDN is a system of distributed servers (network) that deliver pages and other Web content to a user, based on the geographic locations of the user, the origin of the webpage and the content delivery server.
What is DNS?
Domain Name Servers (DNS) are the Internet's equivalent of a phone book. They maintain a directory of domain names and translate them to Internet Protocol (IP) addresses. This is necessary because, although domain names are easy for people to remember, computers or machines, access websites based on IP addresses.`
What is Health Check?
Health check is the process of checking if a particular resource(server/API) is working or not. For example, to discover the availability of your EC2 instances, a load balancer periodically sends pings, attempts connections, or sends requests to test the EC2 instances. These tests are called health checks.
What is a Container?
A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another. A Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings.
What is a Message Queue?
A message queue is a form of asynchronous service-to-service communication used in serverless and microservices architectures. Messages are stored on the queue until they are processed and deleted. Each message is processed only once, by a single consumer.
What are Roles and Keys?
An IAM role is an IAM entity that defines a set of permissions for making AWS service requests
What is SSO?
Single sign-on (SSO) is an authentication process that allows a user to access multiple applications with one set of login credentials
What is Orchestration?
Cloud orchestration is the use of programming technology to manage the interconnections and interactions among workloads on public and private cloud infrastructure. It connects automated tasks into a cohesive workflow to accomplish a goal, with permissions oversight and policy enforcement.
What is IoT?
The Internet of things (IoT) is the network of devices such as vehicles, and home appliances that contain electronics, software, actuators, and connectivity which allows these things to connect, interact and exchange data.
What is the difference between SQL and NoSQL DB?
SQL databases defines and manipulates data based structured query language (SQL)
SQL requires you to use predefined schemas to determine the structure of your data before you work with it. Also all of your data must follow the same structure
A NoSQL database has dynamic schema for unstructured data. Data is stored in many ways which means it can be document-oriented, column-oriented, graph-based or organized as a KeyValue store. This flexibility means that documents can be created without having defined structure first. Also each document can have its own unique structure."
What is Web Application Firewall (WAF)?
AWS WAF is a web application firewall that helps protect your web applications from common web exploits that could affect application availability, compromise security, or consume excessive resources. AWS WAF gives you control over which traffic to allow or block to your web applications by defining customizable web security rules. You can use AWS WAF to create custom rules that block common attack patterns, such as SQL injection or cross-site scripting, and rules that are designed for your specific application
What is IAM?
AWS Identity and Access Management (IAM) is a web service that helps you securely control access to AWS resources
What is Serverless Architecture?
A serverless architecture is a way to build and run applications and services without having to manage infrastructure. Your application still runs on servers, but all the server management is done by Cloud provider.
Serverless architecture (also known as serverless computing or function as a service, FaaS) is a software design pattern where applications are hosted by a third-party service, eliminating the need for server software and hardware management by the developer
What is the difference between Verticle Scaling and Horizontal scaling?
Horizontal scaling means that you scale by adding more machines into your pool of resources whereas Vertical scaling means that you scale by adding more power (CPU, RAM) to an existing machine.
What is API Gateway?
The API Gateway takes all the requests from the clients, then routes them to the appropriate microservice with request routing, composition, and protocol translation. Typically it handles a request by invoking multiple microservices and aggregating the results, to determine the best path.
For most microservices based applications, it makes sense to implement an API Gateway, which acts as a single entry point into a system. The API Gateway is responsible for request routing, composition, and protocol translation. It provides each of the application's clients with a custom API
API Gateway handles all the tasks involved in accepting and processing up to hundreds of thousands of concurrent API calls, including traffic management, authorization and access control, monitoring, and API version management.
What is Elasticity? (EC2, EFS)
Elasticity is the ability to grow or shrink infrastructure resources dynamically as needed to adapt to workload changes in an autonomic manner, maximizing the use of resources.
What is the DevOps?
DevOps is the combination of cultural philosophies, practices, and tools that increases an organization's ability to deliver applications and services at high velocity: evolving and improving products at a faster pace than organizations using traditional software development and infrastructure management processes.
What is Hybrid Cloud?
Hybrid cloud is a cloud computing environment that uses a mix of on-premises, private cloud and third-party, public cloud services with orchestration between the two platforms.
A hybrid cloud is a computing environment that combines a public cloud and a private cloud by allowing data and applications to be shared between them."
What is Kubernetes?
Kubernetes is a powerful open-source system, initially developed by Google, for managing containerized applications in a clustered environment. It aims to provide better ways of managing related, distributed components and services across varied infrastructure.
Are Docker and Kubernetes different?
Docker is a platform and tool for building, distributing, and running Docker containers.
Kubernetes is a container orchestration system for Docker containers.
Onpremise deployment vs Cloud Deployment
On-premise deployment is the process of installing software locally on a company's own computers and servers.
Cloud deployment is installing software on cloud servers and accessed through a web browser.
What is Cloud Migration?
Cloud migration is the process of moving data, applications or other business elements to a cloud computing environment from an on-premise environment or another cloud environment.
What is Lift & Shift in Cloud Migration?
Lift and shift is a strategy for moving an application or operation from one environment to another â€“ without redesigning the app.
What is Disaster Recovery?
Disaster recovery (DR) is an area of security planning that aims to protect an organization from the effects of significant negative events. DR allows an organization to maintain or quickly resume mission-critical functions following a disaster.
What is Gartner Magic Quadrant?
Gartner Magic Quadrant research methodology provides a graphical competitive positioning of four types of technology providers in fast-growing markets: Leaders, Visionaries, Niche Players and Challengers.
What is RPO and RTO in Disaster Recovery?
RTO stands for Recovery Time Objective. It is the maximum tolerable time allowed to recover client systems after a disaster scenario has been declared.
RPO stands for Recovery Point Objective. It is the measure of the maximum acceptable data loss recorded by time, or the maximum allowed age of the data when recovering a clientâ€™s system. RPO is measured from the time the first transaction is lost or from the time the hosting services became unavailable.
What is VPC? (Public Network vs Private Network)
A virtual private cloud (VPC) is an on-demand configurable pool of shared computing resources allocated within a public cloud environment, providing a certain level of isolation between the different organizations using the resources.
What is the principle of least privilege?
The principle of least privilege (POLP), an important concept in computer security, is the practice of limiting access rights for users to the bare minimum permissions they need to perform their work. Under POLP, users are granted permission to read, write or execute only the files or resources they need to do their jobs.
What is Shared Responsibility Model?
A shared responsibility model is a cloud security framework that dictates the security obligations of a cloud computing provider and its users to ensure accountability
What is High Availability?
High availability refers to systems that are durable and likely to operate continuously without failure for a long time. The term implies that parts of a system have been fully tested and, in many cases, that there are accommodations for failure in the form of redundant components.
Why is caching important?
Cloud is all about how quick the data can be delivered to the end user. Instead of querying the server everytime for the data, it is wise to maintain a copy of static/recently pulled data in a near by location(CDN) or in-memory(Redis).
What is Docker Registry?
A docker registry is a storage and content delivery system, holding named Docker images, available in different tagged versions
What is Routing Policy?
Routing policy is a policy for cloud resources that define the routing of the incoming request.
What is Read Replica?
Read replica is an additional copy of database that shares the database read query loads.
What is Sharding?
Sharding is a type of database partitioning that separates very large databases the into smaller, faster, more easily managed parts called data shards.
What is Storage Gateway?
A cloud storage gateway is a network appliance or server which resides at the customer premises and translates cloud storage APIs such as SOAP or REST to block-based storage protocols such as iSCSI or Fibre Channel or file-based interfaces such as NFS or SMB.
What is the difference between Durability and Availability?
Availability and durability are two very different aspects of data accessibility.
Availability refers to system uptime, i.e. the storage system is operational and can deliver data upon request. Historically, this has been achieved through hardware redundancy so that if any component fails, access to data will prevail.
Durability, on the other hand, refers to long-term data protection, i.e. the stored data does not suffer from bit rot, degradation or other corruption. Rather than focusing on hardware redundancy, it is concerned with data redundancy so that data is never lost or compromised.
Eventual Consistency vs Strong Consistency
Eventual consistency is a theoretical guarantee that, provided no new updates to an entity are made, all reads of the entity will eventually return the last updated value.
In contrast, traditional relational databases have been designed based on the concept of strong consistency, also called immediate consistency. This means that data viewed immediately after an update will be consistent for all observers of the entity. This characteristic has been a fundamental assumption for many developers who use relational databases.
Strong Consistency offers up-to-date data but at the cost of high latency.
Eventual consistency offers low latency at the risk of returning stale data
What is Data Lifecycle Management?
Data life cycle management (DLM) is a policy-based approach to managing the flow of an information system's data throughout its life cycle from creation and initial storage to the time when it becomes obsolete and is deleted.
What is a NAT (Network Address Translation)?
NAT is an Internet standard that enables a local-area network (LAN) to use one set of IP addresses for internal traffic and a second set of addresses for external traffic.
When NAT is used in this way, all users inside the private network access the Internet have the same public IP address when they use the Internet.
What is Bastion Host?
A bastion host is a specialized computer that is deliberately exposed on a public network. From a secured network perspective, it is the only node exposed to the outside world and is therefore very prone to attack.
The bastion host processes and filters all incoming traffic and prevents malicious traffic from entering the network, acting much like a gateway.
A bastion host is a server whose purpose is to provide access to a private network from an external network, such as the Internet. Because of its exposure to potential attack, a bastion host must minimize the chances of penetration.
What is API End point?
An endpoint is a URL pattern used to communicate with an API.
What is VPC End point?
A VPC endpoint enables you to create a private connection between your VPC and another AWS service without requiring access over the Internet, through a NAT device, a VPN connection, or AWS Direct Connect.
What is Security Group?
A security group is a set of IP filter rules that define how to handle incoming (ingress) and outgoing (egress) traffic to both the public and private interfaces of a virtual server instance. The rules that you add to a security group are known as security group rules.
What is Access Control List (ACL)?
A network access control list (ACL) is an optional layer of security for your VPC that acts as a firewall for controlling traffic in and out of one or more subnets. We can set up network ACLs with rules similar to your security groups in order to add an additional layer of security to your VPC.
What is Fault Tolerance?
Fault tolerance is the property that enables a system to continue operating properly in the event of the failure of some (one or more faults within) of its components.
What is Machine Image?
A machine image is a template for creating new instances. You can choose images from a catalog to create images or save your own images from running instances.
The images can be plain operating systems or can have software installed on them, such as databases, application servers, or other applications."
What is Saas, Paas and Iaas?
Software as a service (Saas) is a software licensing and delivery model in which software is licensed on a subscription basis and is centrally hosted.
Platform as a Service (PaaS) or Application Platform as a Service (aPaaS) or platform-based service is a category of cloud computing services that provides a platform allowing customers to develop, run, and manage applications without the complexity of building and maintaining the infrastructure
Infrastructure as a service (IaaS) is a form of cloud computing that provides virtualized computing resources over the internet. "
What is VPC Peering?
A VPC Peering connection is a networking connection between two VPCs that enables you to route traffic between them using private IPv4 addresses or IPv6 addresses
What is Internet Gateway?
An internet gateway is a horizontally scaled, redundant, and highly available VPC component that allows communication between instances in your VPC and the internet.
What is Reserved Instance and On-Demand Instance?
A Reserved Instance is a reservation of resources and capacity, for either one or three years, for a particular Availability Zone within a region. Unlike on-demand, when you purchase a reservation, you commit to paying for all of the hours of the 1- or 3-year term; in exchange, the hourly rate is lowered significantly.
On-Demand Instances are servers that can be purchased as and when needed at a higher rate than the reserved instance.
There are different use cases for picking Reserved and On-Demand instances.
What is BYOL Licensing model?
Bring your own license (BYOL) is the process you can use to deploy software that you've previously licensed on to a cloud server.
What is Web Service?
A Web service is a software service used to communicate between two devices on a network.
Web service is a software application with a standardized way of providing interoperability between disparate applications. It does so over HTTP using technologies such as XML, SOAP, WSDL, and UDDI.
What is MFA(Multi Factor Authentication)?
Multi-factor authentication (MFA) is an authentication method in which a computer user is granted access only after successfully presenting two or more pieces of evidence to an authentication mechanism.
MFA is built from a combination of physical, logical and biometric validation techniques used to secure a facility, product or service."
What is Microservice Architecture?
Microservices architecture is an architectural style that structures an application as a collection of services that loosely coupled, independently deployable, highly maintainable and testable.
What is Loosely Coupled Architecture?
Loosely coupled architecture is an approach to interconnecting the components in a system or network so that those components depend on each other to the least extent practicable.
What is column-oriented DBMS?
A column-oriented DBMS (or columnar database management system) is a database management system (DBMS) that stores data tables by column rather than by row.
Column-oriented databases can provide a 100x speedup than normal databases. Particularly for time-series data, column-oriented databases have been successfully used to deliver fast storage and analysis."
What is Multi-tier architecture?
In software engineering, multitier architecture or multilayered architecture is a clientâ€“server architecture in which presentation, application processing, and data management functions are physically separated.
What is multi-tenant cloud?
A multi-tenant cloud is a cloud computing architecture that allows customers to share computing resources in a public or private cloud. Each tenant's data is isolated and remains invisible to other tenants.
What is Sticky session?
Sticky session refers to the feature of many commercial load balancing solutions for web-farms to route the requests for a particular session to the same physical machine that serviced the first request for that session.
What is Self-Healing architecture?
Self-healing architecture describes any device or system that has the ability to perceive that it is not operating correctly and, without human intervention, make the necessary adjustments to restore itself to normal operation.
What is Provisioned IOPS?
Provisioned IOPS are a new EBS volume type designed to deliver predictable, high performance for I/O intensive workloads, such as database applications, that rely on consistent and fast response times.
What is connection draining?
Connection draining is an option to let the instance that its going to be shutdown shortly by the load balancer. This will allow to complete in-flight requests made to instances that are de-registering or unhealthy.
What is IOPS?
Input/output operations per second is an input/output performance measurement used to characterize computer storage devices like hard disk drives, solid state drives, and storage area networks.
What are Pre-Signed URLs?
A presigned URL gives you access to the object identified in the URL, provided that the creator of the presigned URL has permissions to access that object.
What is Long Poll and Short Poll in Message Queues?
Polling is the process of querying the queues to check if there are any new messages in the queue for processing.
Amazon SQS long polling is a way to retrieve messages from your Amazon SQS queues. While the regular short polling returns immediately, even if the message queue being polled is empty, long polling doesnâ€™t return a response until a message arrives in the message queue, or the long poll times out.
Short Polling returns immediately if the queue is empty.
There are various use cases for each method and we need to pick the polling method based on specific use case.
What is decoupling?
Decoupled architecture is a type of computing architecture that enables computing components or layers to execute independently while still interfacing with each other. Decoupled architecture separates a system's memory access and instruction cycle processes from execution-stage processes by implementing a data buffer.
High Availability vs Fault Tolerance architecture
High availability (HA) is a characteristic of a system, which aims to ensure an agreed level of operational performance, usually uptime, for a higher than normal period.
Fault tolerance is the property that enables a system to continue operating properly in the event of the failure of some (one or more faults within) of its components.
What is Intrusion Detection and Intrusion Protection?
Intrusion Detection Systems (IDS) analyze and monitor network traffic for signs that indicate attackers are using a known cyberthreat to infiltrate or steal data from your network. IDS systems compare the current network activity to a known threat database to detect several kinds of behaviors like security policy violations, malware, and port scanners.
Intrusion Prevention Systems (IPS) live in the same area of the network as a firewall, between the outside world and the internal network. IPS proactively deny network traffic based on a security profile if that packet represents a known security threat."
What is the difference between OLAP and OLTP?
OLTP and OLAP both are the online processing systems. OLTP is a transactional processing while OLAP is an analytical processing system.
The basic difference between OLTP and OLAP is that OLTP is an online database modifying system, whereas, OLAP is an online database query answering system.
What are Leader Nodes and Worker Nodes?
Leader node is the primary manager node that makes all management and orchestration decisions.
Worker Node is the Slave Node. Master node assign work and worker node actually perform the assigned tasks. Worker node processes the data stored on the node, they report the resources to the master/leader node.
What is Edge Location?
An edge location is where end users access services located at AWS or any other cloud provider. They are located in most of the major cities around the world and are specifically used by CloudFront (CDN) to distribute content to end user to reduce latency.
What is Region and Availability Zone?
Each Region is a separate geographic area. Each region has multiple, isolated locations known as Availability Zones.
What is Key pair?
Cloud providers use publicâ€“key cryptography to encrypt and decrypt login information. Publicâ€“key cryptography uses a public key to encrypt a piece of data, such as a password, then the recipient uses the private key to decrypt the data. The public and private keys are known as a key pair.
What is Ephemeral storage?
Ephemeral storage is the volatile temporary storage attached to your instances which is only present during the running lifetime of the instance. In the case that the instance is stopped or terminated or underlying hardware faces an issue, any data stored on ephemeral storage would be lost.
What is Inbound traffic and Outbound traffic?
Inbound traffic is the traffic coming to the reserver. Outbound traffic is the traffic going from the server.
What is TCO?
Total cost of ownership(TCO) is the estimate of all the direct and indirect costs involved in acquiring and operating a product or system over its lifetime.
What is Cloud Portability?
Cloud portability is the ability to move applications and data from one cloud computing environment to another with minimal disruption. Cloud portability enables the migration of cloud services from one cloud provider to another or between a public cloud and a private cloud.
What is SLA?
A service-level agreement is a commitment between a service provider and a client. Particular aspects of the service â€“ quality, availability, responsibilities â€“ are agreed between the service provider and the service user.
What is Big Data?
Big data is a term used to refer to data sets that are too large or complex for traditional data-processing application software to adequately deal with.
What is Continuous Integration?
Continuous Integration (CI) is a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early.
What does 12-Factor Apps mean?
The Twelve-Factor App methodology is a methodology for building software as a service applications. These best practices are designed to enable applications to be built with portability and resilience when deployed to the web.
What is Ingress traffic and egress traffic?
Ingress traffic is composed of all the data communications and network traffic originating from external networks and destined for a node in the host network. Ingress traffic can be any form of traffic whose source lies in an external network and whose destination resides inside the host network.
Egress traffic is network traffic that begins inside of a network and proceeds through its routers to a destination somewhere outside of the network.
What is In-Memory database?
An in-memory database (IMDB, also main memory database system or MMDB or memory resident database) is a database management system that primarily relies on main memory for computer data storage. It is contrasted with database management systems that employ a disk storage mechanism.
What is SAML?
Security Assertion Markup Language (SAML) is an open standard for exchanging authentication and authorization data between parties, in particular, between an identity provider and a service provider. SAML is an XML-based markup language for security assertions.
What is Identity Federation?
Federated identity management (FIM) is an arrangement that can be made between multiple enterprises to let subscribers use the same identification data to obtain access to the networks of all the enterprises in the group. The use of such a system is sometimes called identity federation.
Federation enables you to manage access to your AWS Cloud resources centrally. With federation, you can use single sign-on (SSO) to access your AWS accounts using credentials from your corporate directory. Federation uses open standards, such as Security Assertion Markup Language 2.0 (SAML), to exchange identity and security information between an identity provider (IdP) and an application.
What is OAuth?
OAuth (Open Authorization) is an open standard for token-based authentication and authorization on the Internet.
OAuth doesn't share password data but instead uses authorization tokens to prove an identity between consumers and service providers. OAuth is an authentication protocol that allows you to approve one application interacting with another on your behalf without giving away your password.
What does Failover mean?
Failover is a backup operational mode in which the functions of a system component (such as a processor, server, network, or database, for example) are assumed by secondary system components when the primary component becomes unavailable through either failure or scheduled down time
Failover is the constant capability to automatically and seamlessly switch to a highly reliable backup. This can be operated in a redundant manner or in a standby operational mode upon the failure of a primary server, application, system or other primary system component.
What is RAID?
RAID (Redundant Array of Independent Disks, originally Redundant Array of Inexpensive Disks) is a data storage virtualization technology that combines multiple physical disk drive components into one or more logical units for the purposes of data redundancy, performance improvement, or both.


It's important to pay attention to security in just about everything we do as developers. It's impossible to check everything from within the middle layer without making sacrifices to performance and features. xxm has a few design choices and features added to help build secure applications, but in the end it still takes a bit of work and attention from your end. Here are a few known issues, tips and tricks, but new soft spots may appear, both in xxm and in other applications out there on the web, so keep an eye and ear open.
things xxm does
XSS (cross-site-scripting)
Most cross-site-scripting can be prevented by choosing correctly between Context.Send(x)
(or [[=x]]
) and Context.SendHTML(x)
(or [[#x]]
). In fact, it's strongly advised to use normal Send ([[=x]]
) in most cases, and only use SendHTML ([[#x]]
) in those cases where it's neccessary, and even then never on strings retrieved from database or a Context.Parameter[]
unless it's properly stripped from any possibly malicous code (HTML and JavaScript).
You might worry about performance when HTMLEncode gets called on almost everything, but xxm's several overload functions don't call HTMLEncode on variant types where it doesn't matter, such as numeric values.
SQL injection
xxmData.pas
uses ADO command parameters to run queries. This encapsulates parameter values safely into the SQL to perform.
See xxm_demo.zip demo "03 Data" for an example.
scripted posting
The default xxmSession.pas
denies page access if a new session is created on a POST request.
things xxm doesn't do
when to pass values over form fields, url parameters, session data, cookies
The default xxmSession.pas
uses Context.SessionID
which creates an XxmSession cookie. This value is used to retrieve a session data object into a Session
threadvar from the session store. Add identifying information to the session object (such as a user ID as used in the database) but only allow changes under proper authentication (such as login and password).
//TODO: alternative proto templates could add a Session local variable to the default TxxmFragment class inherited from by each fragment/page.
Never pass values that are not supposed to change over URL parameters or form fields. By passing them to the browser and picking up the values when they return, you enable the user to modify the values. One exception may be acceptable to this rule: identifying values (see also re-validate posted forms).
A method to protect data stored in (persistent) cookies (that is a cookie with an expiry date in the future) is encryption, or using an id refering to data in the database.
check a Context.Parameter
is a POST parameter from a form field (not a GET parameter from the query string in the URL)
Context.Parameter
provides access to all parameters of the page request, all parameters expose the IXxmParameter interface, but a POST parameter does expose the IXxmPostParameter interface. Check this by using as
or QueryInterface
If you perform client-side validation, or have sections of the form that are hidden depending on authentication or priveleges, re-check values and permissions when processing posted values.
prevent you from making mistakes
I've elected to not include this in the design goals of xxm. You're supposed to know what your doing, and be responsible about working on an online platform that will respond to requests of people. Even if they have malicious intent or are not even people but automated bots that search for vulnerabilities of your web-solution.
more reading


{% extends "base_template.html" %} {% block content %}
Here's will information on the Forecast will go


Welcome to Arche’s documentation!
¶
Contents:
Quickstart
Basic Usage
Schema Validation
Environment variables
Handling items of different types
Strategy
Main purpose
Short-term
Long-term
src
arche package
Notebooks
Basics
Compare jobs
API
Indices and tables
Indices and tables
¶
Index
Module Index
Search Page
Arche
Navigation
Contents:
Quickstart
Handling items of different types
Strategy
src
Notebooks
Indices and tables
Related Topics
Documentation overview
Next:
Quickstart
Quick search


class: center, middle, inverse, title-slide # Lecture 7 ## Environmental policy with pre-existing distortions ### Ivan Rudik ### AEM 6510 --- exclude: true ```r if (!require("pacman")) install.packages("pacman") ``` ``` ## Loading required package: pacman ``` ```r pacman::p_load( tidyverse, tidylog, xaringanExtra, rlang, patchwork ) options(htmltools.dir.version = FALSE) knitr::opts_hooks$set(fig.callout = function(options) { if (options$fig.callout) { options$echo <- FALSE } knitr::opts_chunk$set(echo = TRUE, fig.align="center") options }) ``` ``` ## Warning: 'xaringanExtra::style_panelset' is deprecated. ## Use 'style_panelset_tabs' instead. ## See help("Deprecated") ``` ``` ## Warning in style_panelset_tabs(...): The arguments to `syle_panelset()` changed ## in xaringanExtra 0.1.0. Please refer to the documentation to update your slides. ``` --- # Roadmap So far we have looked at single sector (partial equilibrium) economies with: - Pollution distortions - Competitive markets - Market power distortions -- Now we will learn about multi-sector (general equilibrium) economies How does environmental policy spillover into these other sectors? How does environmental policy interact with revenue-raising taxes (e.g. income taxes)? --- # Environmental policy with leisure First we extend the model so that labor supply is .hi-blue[elastic] - Households have a choice of either working or leisure time -- To focus on the key intuition we assume: `\(^1\)` - There is a representative (single) firm - There is a representative household -- This allows us to treat individual and aggregate behavior the same .footnote[1: The underlying critical assumption is that utility and profit functions take what's called a Gorman form.] --- # Environmental policy with leisure Define the following: - `\(X\)` is consumption of the polluting good - `\(Z\)` is consumption of the *numeraire* good (i.e. the relative good) - `\(N\)` is the hours of leisure time - `\(E\)` is aggregate emissions -- Utility is then: `$$U(X,Z,N,E) = U(X,N) + Z - D(E)$$` where `\(U_{XX}, U_{NN} < 0\)` and `\(U_{XX}U_{NN}-U_{NX}^2 > 0\)` and the person is endowed with some amount of time `\(T\)` to allocate between work and leisure --- # Environmental policy with leisure Wages earned by the household are `\(w\)`, and we assume demand for labor is perfectly elastic -- i.e. demand is horizontal at `\(w\)` -- Household income is then: `\(w\cdot(T-N)\)` -- We can now write the households utility maximization problem as: `$$\max_{X,N,Z} U(X,Z,N,E) = U(X,N) + Z - D(E) \\ \text{ subject to: } \,\,\,\, w\cdot(T-N) = Z + pX$$` --- # Environmental policy with leisure We can substitute the budget constraint in for `\(Z\)` to get an unconstrained problem: `$$\max_{X,N} U(X,Z,N,E) = U(X,N) + w\cdot(T-N) - pX - D(E)$$` -- with FOCs: `$$U_X = p \qquad U_N = w$$` which implicitly define the demand function for consumption `\(X(p,w)\)` and the demand function for leisure `\(N(p,w)\)` --- # Environmental policy with leisure How do choices of `\(X,N\)` respond to a change in price `\(p\)`? -- Differentiate both FOCs with respect to p: -- `$$U_{XX} {\partial X \over \partial p} + U_{XN} {\partial N \over \partial p} = 1 \qquad U_{NN} {\partial N \over \partial p} + U_{XN} {\partial X \over \partial p} = 0$$` -- We have two equations and two unknowns so we can solve to get: `$${\partial N \over \partial p} = {-U_{XN} \over U_{XX}U_{NN} - U_{XN}^2} \qquad {\partial X \over \partial p} = {U_{NN} \over U_{XX}U_{NN} - U_{XN}^2}$$` --- # Environmental policy with leisure `$${\partial N \over \partial p} = {-U_{XN} \over U_{XX}U_{NN} - U_{XN}^2} \qquad {\partial X \over \partial p} = {U_{NN} \over U_{XX}U_{NN} - U_{XN}^2}$$` -- `\({\partial X \over \partial p}\)` is negative since `\(U\)` is concave `\((U_{NN} < 0, U_{XX}U_{NN} - U_{XN}^2 > 0)\)` -- The sign of `\({\partial N \over \partial p}\)` equals the sign on `\(-U_{XN}\)` -- If `\(X\)` and `\(N\)` are substitutes, `\(-U_{XN} > 0\)`, and leisure increases in the price of the consumption good -- If they are complements, `\(-U_{XN} < 0\)`, and leisure decreases in the price of the consumption good --- # Environmental policy with leisure If `\(N\)` is going on a picnic and `\(X\)` is hot dogs: `\(X\)` and `\(N\)` are complements -- If the price of hot dogs goes up 1000% then you will go on fewer picnics -- If `\(N\)` is going on a picnic and `\(X\)` is video games: `\(X\)` and `\(N\)` are substitutes -- If the price of video games go up 1000% then you will go on more picnics --- # Environmental policy with leisure The firm side of the economy will be the same as before: it produces `\(X\)` and emits `\(E\)` and for simplicity we will focus on the specific case: `$$\Pi = pX - C(X) \text{ where } E = \delta X$$` -- We will also assume: - `\(\delta=1\)` so we can use `\(E\)` and `\(X\)` interchangeably -- - `\(C'(X) > 0, C''(X) \geq 0\)` -- - The polluting industry's demand for labor is small relative to the entire economy, i.e. wages are effectively fixed for the household --- # Environmental policy with leisure Now lets solve for the social optimum: `$$\max_{X} W = \underbrace{U(X,N) + w\cdot(T-N) - pX - D(X)}_{\text{Consumer Utility}} + \underbrace{pX - C(X)}_{\text{Firm profit}}$$` To focus on interactions with non-regulated industries, we assume the regulator cannot determine leisure -- The consumer chooses `\(N\)` according to the FOC `\(U_N(X^*,N) = w\)` and then `\(Z\)` given the budget constraint `\(Z = w(T-N) - pX^*\)` -- One way you can think about this is as if the regulator imposes a quantity standard `\(X^*\)` and then a market price `\(p^*\)` arises which affects leisure demand --- # Environmental policy with leisure The FOC for the optimum is: `$$U_X - D'(X) - C'(X) + [U_N -w]{\partial N \over \partial X} = 0$$` where the last term captures the households .hi-blue[indirect] leisure response to the regulator's policy choice -- Given household utility maximization `\(U_N -w = 0\)` and the condition is then: `$$U_X - C'(X) = D'(X)$$` -- Marginal abatement cost `\((U_X - C'(X))\)` equals marginal damage `\((D'(X))\)` ! --- # Environmental policy with labor market distortions .hi[Elastic labor supply/leisure doesn't change the efficiency condition] -- Now suppose the government needs to raise revenue with a labor income tax `\(m\)` in order to finance government services -- It needs to finance a budget of size `\(G\)` -- The consumer's utility maximization problem is: `\begin{gather} \max_{X,Z,N} U = u(X,N) + Z - D(E) \\ \text{ subject to } (1-m)w(T-N) = Z + pX \end{gather}` Where the budget is scaled down by `\((1-m)\)` reflecting the income tax --- # Environmental policy with labor market distortions The FOCs are: `$$u_X = p \qquad u_N = (1-m)w$$` -- .hi-blue[The labor tax causes an inefficiency in the labor market:] the marginal value of leisure `\((u_N)\)` is no longer equal to the marginal value of labor `\((w)\)` -- `\(u_N < w\)` which means that the household overconsumes leisure -- Another way to see this is to re-write the FOC as: `$$u_N + mw = w$$` -- The tax `\(m\)` makes the consumer act as if there is a subsidy `\(mw\)` on leisure --- # Environmental policy with labor market distortions .pull-left[ ![excess burden is because MU of leisure is less than wage](7-pre-existing-distortions_files/figure-html/labor_market_1-1.png) ] .pull-right[ `\(N^c\)` is how much leisure the consumer chooses, since `\((1-m)w < w\)` this is too much and induces DWL equal to `\(b\)` This is called .hi-red[excess burden] The tax raises revenues equal to `\(G\)`: `\(mw\times(T-N^c)\)` ] --- # Environmental policy with labor market distortions .pull-left[ ![excess burden is because MU of leisure is less than wage](7-pre-existing-distortions_files/figure-html/labor_market_2-1.png) ] .pull-right[ Suppose `\(N\)` and `\(X\)` are substitutes, and the regulator sets `\(X=X^*\)` where `\(X^* \rightarrow MAC = MD\)` This raises the price of `\(X\)`, shifts leisure demand to the .hi-red[right] New DWL is `\(c\)`, and government revenues are now only `\(d\)` Change in DWL from `\(X^c \rightarrow X^*\)` is indeterminant ] --- # Environmental policy with labor market distortions .pull-left[ ![excess burden is because MU of leisure is less than wage](7-pre-existing-distortions_files/figure-html/labor_market_2-1.png) ] .pull-right[ Fixing the pollution externality had two effects: 1. Indeterminant effect on the distortion in the labor market 2. Reduced the amount of revenue the government raised through labor taxation ] --- # Second-best environmental policy What does the optimal environmental policy look like if there's a pre-existing labor market distortion? -- The government has a budget `\(G\)` it needs to finance using labor taxes or emission taxes -- First let's consider the case where they can only raise revenue via a labor tax: this is non-revenue raising environmental policy --- # Second-best non-revenue raising environmental policy If we cannot raise revenue with the environmental policy, the regulator chooses `\(X\)` (and `\(E\)`) and the marginal tax rate `\(m\)` to maximize the sum of profit and utility, subject to the budget constraint -- The household consumes leisure according to the FOC: `$$U_N(\bar{X},N) = (1-m)w$$` given the regulator chose `\(X=\bar{X}\)` -- The firm obtains profits: `$$\Pi = p\bar{X} - C(\bar{X})$$` --- # Second-best non-revenue raising environmental policy The marginal value of the dirty good comes from the consumers inverse demand: `$$P(\bar{X}) = u_X(\bar{X},N)$$` which depends on `\(N\)` -- First we need to learn how the endogenous variables `\(N\)` and `\(p\)` vary with `\(\bar{X}\)`? -- Let's do the comparative statics: differentiate the consumer's two FOCs with respect to `\(\bar{X}\)` --- # Second-best non-revenue raising environmental policy `\begin{align} u_{XX}\frac{\partial \bar{X}}{\partial \bar{X}} + u_{XN} \frac{\partial N}{\partial \bar{X}} &= \frac{\partial p}{\partial \bar{X}} \tag{X FOC} \\ u_{NX}\frac{\partial \bar{X}}{\partial \bar{X}} + u_{NN} \frac{\partial N}{\partial \bar{X}} &= 0 \tag{N FOC} \end{align}` `\(\frac{\partial \bar{X}}{\partial \bar{X}} = 1\)` so two equations, two unknowns; solving the system gives us: `\begin{align} \frac{\partial N}{\partial \bar{X}} &= - {u_{XN} \over u_{NN}} \\ \frac{\partial p}{\partial \bar{X}} &= {u_{XX}u_{NN} - u_{NN}^2 \over u_{NN}} < 0 \end{align}` `\(\text{sign}(\frac{\partial N}{\partial \bar{X}})\)` depends on whether `\(X\)` and `\(N\)` are complements or substitutes --- # Second-best non-revenue raising environmental policy Now that we know how the firm responds, return to the regulator's problem: `$$\max_{X,m} u(X,N) + Z - D(X) + pX - C(X) \text{ s.t. } wm(T-N) = G$$` -- We still need to decide what the government does with its revenue -- For convenience, we assume its returned to the consumer as a lump sum transfer so that: `$$Z=(1-m)w(T-N)-pX+G = (1-m)w(T-N)-pX+wm(T-N)\\ \Rightarrow Z = w(T-N) - pX$$` Income is unchanged for a given level of `\(N\)` under the tax and transfer --- # Second-best non-revenue raising environmental policy The regulator's problem is then: `$$\max_{X,m} u(X,N) + w(T-N) - D(X) - C(X) + \lambda[ wm(T-N) -G]$$` `\(\lambda\)` is called the .hi[marginal welfare cost of public funds] -- It measures the welfare cost of raising revenue by taxing labor -- What's the FOC for `\(m\)`? --- # Second-best non-revenue raising environmental policy The FOC for `\(m\)` is: `$$(u_N - w){\partial N \over \partial m} + \lambda \left[w(T-N)-wm {\partial N \over \partial m} \right] = 0$$` -- The household's optimal choice of `\(N\)` tells us that: `\(-mw = u_N - w\)`, we can substitute this in to get `\(\lambda\)`: -- `$$\lambda = \frac{w m {\partial N \over \partial m}}{w(T-N)-wm{\partial N \over \partial m}}$$` -- Whats the interpretation of the right hand side? --- # Second-best non-revenue raising environmental policy `$$\lambda = \frac{w m {\partial N \over \partial m}}{w(T-N)-wm{\partial N \over \partial m}}$$` -- The numerator is: -- The welfare cost of changing `\(m\)` -- Why? -- Higher `\(m\)` increases leisure demand `\({\partial N \over \partial m}\)` -- This times the .hi[tax wedge] `\(mw\)`, the gap between `\(w\)` and actual wage after taxes, gives us the change in excess burden (i.e. the DWL `\(d\)` in the graph) --- # Second-best non-revenue raising environmental policy `$$\lambda = \frac{w m {\partial N \over \partial m}}{w(T-N)-wm{\partial N \over \partial m}}$$` The denominator is: -- The change in tax revenue from higher `\(m\)` -- First term is the increase in marginal revenue -- Second term is the decrease in inframarginal revenue - Similar to `\(P(X) + P'(X)X\)` for a monopolist --- # Second-best non-revenue raising environmental policy `$$\lambda = \frac{w m {\partial N \over \partial m}}{w(T-N)-wm{\partial N \over \partial m}}$$` Numerator and denominator combined give us: The change in welfare from a change in `\(m\)` -- over -- the change in tax revenue from a change in `\(m\)` -- This is the change in welfare from a change in tax revenue! --- # Second-best non-revenue raising environmental policy Now consider the FOC for `\(X\)`: `$$u_X - D'(X) - C'(X) + \left[ u_N - w - \lambda w m \right] {\partial N \over \partial X} = 0$$` -- Recall that we know: `$$-wm = u_N - w \qquad \frac{\partial N}{\partial X} = \frac{\partial N}{\partial p}\frac{\partial p}{\partial X}$$` So that we can substitute in the consumer leisure response: -- `$$u_X - C'(X) + (1+\lambda)\left[-{\partial N \over \partial p}\frac{\partial p}{\partial X}\right]wm = D'(X)$$` --- # Second-best non-revenue raising environmental policy `$$u_X - C'(X) + (1+\lambda)\left[-{\partial N \over \partial p}\frac{\partial p}{\partial X}\right]wm = D'(X)$$` -- What are each of the terms: -- `\(u_X - C'(X)\)` is the marginal abatement cost -- `\(D'(X)\)` is marginal damage -- `\((1+\lambda)\left[-{\partial N \over \partial p}\frac{\partial p}{\partial X}\right]wm\)` is new -- What's the interpretation? --- # Second-best non-revenue raising environmental policy `\((1+\lambda)\left[-{\partial N \over \partial p}\frac{\partial p}{\partial X}\right]wm\)` is called the .hi-blue[marginal interaction effect (MIE)] -- It tells us how the optimal choice of `\(X\)` departs from `\(X^*\)` because of the labor market distortion - Changing `\(\bar{X}\)` changes the price `\(p\)` which changes the household's optimal choice of `\(N\)` -- We need to account for this because the household's choice of leisure will respond to changes in `\(X\)` -- Suppose `\(N\)` and `\(X\)` are substitutes, what does this mean? --- # Second-best non-revenue raising environmental policy Substitutes means that `\(MIE > 0\)` -- The marginal social cost of abatement `\((MAC + MIE)\)` has become .hi-red[larger] -- Intuition? -- Its more socially costly to reduce `\(X\)` because the household increases `\(N\)` in response -- This .hi-red[exacerbates] the distortion caused by the income tax: the household was already undersupplying labor because of the income tax --- # Second-best non-revenue raising environmental policy Complements means that `\(MIE < 0\)` -- The marginal social cost of abatement `\((MAC + MIE)\)` has become .hi-blue[smaller] -- Intuition? -- Its less socially costly to reduce `\(X\)` because the household decreases `\(N\)` in response -- This .hi-blue[alleviates] the distortion caused by the income tax: the household was undersupplying labor because of the income tax, but now reducing `\(X\)` increases labor supply --- # Second-best non-revenue raising environmental policy .pull-left[ ![excess burden is because MU of leisure is less than wage](7-pre-existing-distortions_files/figure-html/labor_market_2-1.png) ] .pull-right[ `\(N^c \rightarrow N^*\)` when `\(p^c \rightarrow p^*\)` because of a change in `\(X\)` This is `\(-{\partial N \over \partial p}\frac{\partial p}{\partial X}\)` This reduces tax revenue by `\(e+c\)` which is just `$$(N^* - N^c)(w - (1-m)w) \\ = (N^* - N^c)mw$$` ] --- # Second-best non-revenue raising environmental policy The marginal welfare cost of recouping the lost tax revenue by raising `\(m\)` is `\(\lambda\)` giving us a total welfare cost of: `$$\lambda (N^* - N^c)mw$$` But `\((N^* - N^c)mw\)` is also the excess burden: its a .hi-red[direct welfare loss!] So the total welfare loss is: `$$(1+\lambda) (N^* - N^c)mw$$` The discrete version of MIE! --- # Findings recap If there's a government revenue constraint, and it can only be met with labor taxes then: 1. The marginal social cost of reducing `\(X\)` is higher than the first-best if `\(X\)` and `\(N\)` are substitutes and lower if they are complements -- 2. The optimal level of pollution is larger if they are substitutes, lower if they are complements -- 3. The absolute value of the difference in first and second-best pollution levels is larger if: - Labor supply is more elastic - Demand for `\(X\)` is more inelastic - Elasticity of substitution between `\(N\)` and `\(X\)` is greater --- # Second-best non-revenue raising environmental policy We didn't actually show the last part yet -- First define: - `\(\varepsilon_x\)` as the own price elasticity `\({\frac{\partial X}{\partial p} \frac{p}{X}}\)` - `\(\eta_{XN}\)` as the elasticity of substitution between `\(X\)` and `\(N\)`: `\({\frac{\partial X}{\partial w} \frac{(1-m)w}{X}}\)` -- and take advantage of the .hi-blue[Slutsky symmetry condition] `\(\partial N / \partial p = \partial X / \partial w\)` We can then use these to substitute into the MIE and get: `$$MIE = (1+\lambda)\left[- {\eta_{XN} \over \varepsilon_X}\right]p {m \over 1-m}$$` --- # Second-best non-revenue raising environmental policy `$$MIE = (1+\lambda)\left[- {\eta_{XN} \over \varepsilon_X}\right]p {m \over 1-m}$$` MIE bigger if `\(|\eta_{XN}|\)` is bigger (higher elasticity of substitution) -- MIE bigger if `\(|\varepsilon_X|\)` is smaller (more inelastic demand for `\(X\)`) -- Still need to show labor supply part --- # Second-best non-revenue raising environmental policy Define the elasticity of labor supply .hi[at the after-tax wage] as: `$$\varepsilon_{L} = - {\partial N \over \partial w}{(1-m)w \over L}$$` -- And recognize that: `$${\partial N(p,(1-m)w) \over \partial m} = -w {\partial N(p,w) \over \partial w}$$` -- Combining these two gives: `$${\partial N \over \partial m}m = \varepsilon_{L} L m / (1-m)$$` --- # Second-best non-revenue raising environmental policy Finally, put: `$${\partial N \over \partial m}m = \varepsilon_{L} L m / (1-m)$$` in `$$\lambda = \frac{w m {\partial N \over \partial m}}{w(T-N)-wm{\partial N \over \partial m}}$$` To get the welfare cost of public funds in terms of fundamental economic parameters --- # Second-best non-revenue raising environmental policy We get: `$$\lambda = \frac{\varepsilon_{L}m/(1-m)}{1- \varepsilon_{L}m/(1-m)}$$` Side note: If labor is more elastic `\(\varepsilon_{L}\)` is larger, the numerator is larger, denominator is smaller `\(\rightarrow\)` MIE is bigger If labor supply is perfectly inelastic (vertical), there is no welfare cost of public funds! --- # Second-best non-revenue raising environmental policy Finally use: `$$\lambda = \frac{\varepsilon_{L}m/(1-m)}{1- \varepsilon_{L}m/(1-m)}$$` to get: `$${m\over(1-m)} = {\lambda \over (1 + \lambda)\varepsilon_L}$$` and then substitute into our MIE expression: `$$MIE = (1+\lambda)\left[- {\eta_{XN} \over \varepsilon_X}\right]p {m \over 1-m}$$` --- # Second-best non-revenue raising environmental policy Finally we will get: `$$MIE = \lambda {-\eta_{XN} \over \varepsilon_X} {p \over \varepsilon_L}$$` and substitute in our expression for `\(\lambda\)`: `$$\lambda = \frac{\varepsilon_{L}m/(1-m)}{1- \varepsilon_{L}m/(1-m)}$$` To get: `$$MIE = p\frac{m/(1-m)}{1- \varepsilon_{L}m/(1-m)} {-\eta_{XN} \over \varepsilon_X}$$` --- # Second-best non-revenue raising environmental policy `$$MIE = p\frac{m/(1-m)}{1- \varepsilon_{L}m/(1-m)} {-\eta_{XN} \over \varepsilon_X}$$` MIE is bigger and the absolute value of the difference in first and second-best pollution levels is larger if: 1. Labor supply is more elastic: `\(\varepsilon_{L}\)` bigger 2. Demand for `\(X\)` is more inelastic: `\(\varepsilon_X\)` smaller 3. Elasticity of substitution between `\(N\)` and `\(X\)` is greater: `\(\eta_{XN}\)` bigger in magnitude --- # Revenue raising environmental policy Now suppose that the government raises revenues via emission taxation or auctioning permits -- In our model the government has a revenue requirement: `$$G=wm(T-N) + \tau X$$` where `\(\tau\)` is the revenue per unit of the dirty good -- The regulator's problem is thus to select two tax rates: `\(m\)` and `\(\tau\)` -- For simplicity we still assume tax revenues are returned lump sum to households --- # Revenue raising environmental policy First derive household spending on the numeraire good: `$$Z = (1-m)w(T-N)-pX+G = w(T-N)-pX+\tau X$$` where the second equality comes from substituting out the govt's budget constraint: `\(G = wm(T-N) + \tau X\)` -- The endogenous variables to be determined are: `\(X\)`, `\(N\)` and `\(p\)`, quantity of the dirty good, leisure, and the price of the dirty good -- These are a function of the govt's choice of `\(m\)` and `\(\tau\)` --- # Revenue raising environmental policy The household FOCs are: `$$u_X = p \qquad u_N = (1-m)w$$` and the firm FOC is: `$$C'(X) = p-\tau$$` -- MU = MC of consumption and leisure MR = MC of production -- Next, as usual, differentiate the FOCs wrt `\(\tau\)` --- # Revenue raising environmental policy This gives us 3 equations and 3 unknown partial derivatives: `$$u_{XX} {\partial X \over \partial \tau} + u_{XN}{\partial N \over \partial \tau} = {\partial p \over \partial \tau} \tag{Household X FOC}$$` `$$u_{XN} {\partial X \over \partial \tau} + u_{NN}{\partial N \over \partial \tau} = 0 \tag{N FOC}$$` `$$C''(X) {\partial X \over \partial \tau} = {\partial p \over \partial \tau} - 1 \tag{Firm X FOC}$$` --- # Revenue raising environmental policy Now solve for how the endogenous variables change in `\(\tau\)` -- `$${\partial X \over \partial \tau} = {u_{NN} \over H} < 0$$` `$${\partial N \over \partial \tau} = {-u_{XN} \over H} \lessgtr 0$$` `$${\partial p \over \partial \tau} = {u_{XX}u_{NN}-u_{XN}^2 \over H} > 0$$` where `\(H = u_{XX}u_{NN}-u_{XN}^2-C''(X)u_{NN} > 0\)` --- # Revenue raising environmental policy Now that we know how the endogenous variables change we can solve for the regulator's optimal taxes -- The regulator wants to maximize social welfare given the budget constraint: `\begin{gather} \max_{m,\tau} U(X,N) + Z - D(X) + pX - C(X) - \tau X \\ \text{ subject to: } wm(T-N)+\tau X=G \end{gather}` -- Substitute in for Z from household spending: `$$Z = w(T-N)-pX+\tau X$$` And look at the `\(\tau\)` FOC --- # Revenue raising environmental policy `$$\left[u_X - C'(X) - D'(X)\right]{\partial X \over \partial \tau} + \lambda\left[X + \tau {\partial X \over \partial \tau} \right] + \left[\underbrace{u_N - w}_{-wm} - \lambda wm\right]{\partial N \over \partial \tau} = 0$$` -- Just follow the same steps as we did with the non-revenue raising case and divide by `\({\partial X \over \partial \tau}\)` to get: `$$\underbrace{u_x - C'(X)}_{MAC} + \underbrace{(1+\lambda)wm\left[-{\partial N \over \partial \tau}\bigg/{\partial X \over \partial \tau}\right]}_{MIE} + \underbrace{\lambda\left[\tau + x/{\partial X \over \partial \tau}\right]}_{MRE} = D'(X)$$` -- Since the tax is per unit, we have that: `\({\partial N \over \partial \tau}\big/{\partial X \over \partial \tau} = {\partial N \over \partial p}\big/{\partial X \over \partial p}\)`, MIE is similar in revenue and non-revenue raising contexts --- # Revenue raising environmental policy What is this new term, `\(MRE\)`: `\(\lambda\left[\tau + x/{\partial X \over \partial \tau}\right]\)`? -- It's the .hi-blue[marginal revenue effect]: the amount by which emission tax revenue changes when `\(X\)` changes, scaled by `\(\lambda\)`, the MC of public funds -- MRE changes the marginal social cost of `\(X\)` because changes in `\(\tau\)` affect how much revenue we need to raise with distorting labor taxation -- Let's get some intuition at the corner case of `\(\tau = 0\)` What's the sign of `\(MRE\)`? --- # Revenue raising environmental policy `\(MRE(\tau=0)\)`: `\(\lambda\left[x/{\partial X \over \partial \tau}\right]\)` -- Here `\(MRE < 0\)` because `\({\partial X \over \partial \tau} < 0\)`, what's the intuition? -- `\(\rightarrow\)` the additional revenue from an increase in `\(\tau\)` lets us reduce labor taxes -- `\(\rightarrow\)` this reduces the distortionary tax in the labor market -- `\(\rightarrow\)` this reduces welfare losses in the labor market -- `\(\rightarrow\)` this reduction in welfare losses reduces the marginal social cost of reducing `\(X\)` --- # Revenue raising environmental policy Is MRE always negative?  --- # Revenue raising environmental policy .pull-left[ ![MRE can increase optimal tax](7-pre-existing-distortions_files/figure-html/negative_mre-1.png) ] .pull-right[ .hi-blue[Demand for dirty good is sufficiently inelastic]: Suppose `\({\partial N \over \partial p}= 0\)` so `\(MIE = 0\)`, `\(C'(X) = c\)`, `\(D'(X) = d\)` Inelastic demand lets us raise more revenue from a small change in the tax ] --- # Revenue raising environmental policy .pull-left[ ![MRE can increase optimal tax](7-pre-existing-distortions_files/figure-html/negative_mre-1.png) ] .pull-right[ Inelastic demand lets us raise more revenue from a small change in the tax This reduces the marginal social cost of reducing X Optimal X with revenue-raising is lower than without: `\(X^{RE} < X^*\)` ] --- # Revenue raising environmental policy .pull-left[ ![MRE can increase optimal tax](7-pre-existing-distortions_files/figure-html/negative_mre-1.png) ] .pull-right[ We can also see that if `\(D'(X)\)` was very large, making `\(\tau\)` larger, we would be where `\(MRE > 0\)` ] --- # Double dividend Is there a prospect for a .hi[double dividend?] There is a .hi-blue[weak double dividend] if welfare is always greater when revenue raised via environmental taxation is used to reduced distortionary taxation rather than refunded lump sum - This is always true -- There is a .hi-red[strong double dividend] if the emission tax should always be set above the `\(MAC = MD\)` level, resulting in greater pollution reductions and more revenue raised - This may or may not be true --- # Double dividend When is there a strong double dividend? -- Recall: `\(MSC = MAC + MIE + MRE\)` -- To have a strong double dividend we need: -- `\(MSC < MAC \Rightarrow MIE + MRE < 0\)` -- This can happen via two pathways: **Pathway 1:** `\(MIE, MRE < 0\)` or, `\(MIE < 0\)` and `\(|MIE| > MRE > 0\)` -- In this pathway we have that leisure and the polluting good are .hi-blue[complements] -- Price of `\(X\)` rises from `\(\tau\)`, demand for leisure goes down, labor goes up --- # Double dividend Is this likely to be true? -- Not really: leisure and consumption are generally substitutes -- **Pathway 2:** `\(MIE > 0 > MRE\)`, `\(|MRE| > MIE\)` -- Here leisure and consumption are substitutes, but the revenue effect dominates the interaction effect -- Let's look at this pathway in more detail --- # Double dividend Again, assume `\(C'(X) = c\)`, this gives us that: `\begin{align} MIE =& \lambda\left(- {\eta_{XN} \over \varepsilon_X} \right){p \over \varepsilon_L} \\ MRE =& \lambda\left({p \over \varepsilon_X} + \tau \right) \end{align}` -- Suppose N and X are *average substitutes* which means `\(\eta_{XN} = \varepsilon_L\)`, then: `$$MIE = \lambda\left(- {p\over \varepsilon_X} \right) < \lambda\left({p \over \varepsilon_X} + \tau \right) = MRE$$` `\(\Rightarrow\)` we shouldn't expect a strong double dividend --- # Revenue raising environmental policy .pull-left[ ![MRE can increase optimal tax](7-pre-existing-distortions_files/figure-html/mac_mie_mre-1.png) ] .pull-right[ Even though there isn't a double dividend, MIE and MRE .hi-red[still matter] for the optimal second-best pollution level Optimal pollution `\(X^{GE}\)` is larger than first-best `\(X^*\)`, but less than the level without revenue recycling `\(X^{IE}\)` ] --- # Policy instruments with labor market distortions How do environmental policy instruments work when we have the distortionary labor tax? -- Taxes and auctioned permits are easy, just set the tax equal to: `$$\tau = D'(X) + MIE + MRE$$` or the number of permits equal to `\(X^{GE}\)` to obtain the optimal second-best outcome -- The regulator obtains revenues `\(\tau X^{GE} = \sigma x^{GE}\)` and recycles it to reduce labor taxation -- What about freely allocated permits or command and control? --- # Policy instruments with labor market distortions This would lead to the same *environmental* outcome, but not achieve the the welfare maximizing outcome Why? -- Free allocation and command and control do not generate revenues that let us reduce labor taxation -- Setting `\(X^{GE} < X^c\)` raises the price of `\(X\)`, increases leisure, and reduces revenues via the interaction effect -- Without revenue from permits or taxes, the optimal pollution level is higher


Enabling Web Inspector on Mac OSX in Desktop 1.2.0
In order to enable the Web Inspector panel in your application on Mac OSX you need to edit the preferences plist file.
This can be found in ~/Library/Preferences and is named using your application's ID. Open the file with the plist editor and add a new key called "WebKitDeveloperExtras" with type set to boolean. Setting this value to true will allow the Inspector panel to be opened.
To open Inspector right click on your application and select "Inspect element". This should cause Inspector to open up.


Your browser does not support the HTML5 Canvas
Connecting to CQC
Client Debug Options:
Log Graphics Cmds
Log Image Processing
Log Miscellaneous Events
Log Mouse/Touch Input
Log Websock Events
Server Debug Options:
Log Msgs Received at Server
Log Server Faux GUI Events
Disable Template Caching
Display Options:
Full Screen Mode
Close


Your browser does not support the video tag.
Your browser does not support the audio element.
date:
time:
calendar:
email:
url:
search:
Points:
points:
Webpage:
W3School
Your browser does not support the canvas element.


Multi-View Interface
This interface shows your scene from 4 separate views. Each quadrant represents a different angle from which you can see and control your objects. In the side, top and front views you can manipulate each object on the 2 axes labeled. In the perspective view you can manipulate the object on any axis desired.
Object Controls:
- Translate: Click the "Translate" icon on the top left of the interface. Now you will be able to move objects. To select an object to move, hover over it and press the left mouse button. To move this object, hold down the left mouse button and drag the mouse to where you want the object positioned.
- Rotate: Click the "Rotate" icon on the top left of the interface. Now you will be able to rotate objects. To select an object to rotate, hover over it and press the left mouse button. To rotate this object, hold down the left mouse button and drag the mouse to where you want the object to rotate to.
- Resetting objects to initial position: On the "reset" dropdown on the toolbar click "Object Position"
Scene Controls:
- Zoom: use the mouse-wheel to zoom in/out in your interface.
- Rotating the scene: If you left-click-and-drag on the scene and have not selected "rotate" or "translate, you will rotate the scene in the direction that you move the mouse. Note that scene rotation is only enabled in the perspective view
- Panning the scene: If you right-click-and-drag on the scene and have not selected "rotate" or "translate, you will pan the scene in the direction that you move the mouse.
- Resetting the scene orientation: On the "reset" dropdown on the toolbar click "Scene Orientation"


Pending Reservation
All Pending Reservation
| Name | People | Time | Details |
|---|---|---|---|
| {{ pending.full_name }} | {{ pending.people_number }} | {{ pending.date_time }} |
Recent Approved Reservation
All Recently Approved Reservation
| Name | People | Time | Details |
|---|---|---|---|
| {{ complete.full_name }} | {{ complete.people_number }} | {{ complete.date_time }} |


I am self-driven and Industrious Graduate Electrical Engineer with keen interest in IoT & Software Development. I am actively learning functional programming in Scala with help of Pluralsight and Packt online training platforms. My career goal is to become a reliable data engineer capable of developing ETL pipelines efficiently.
Training on SMACK stack, Google Cloud Platform and Reactive Systems. I helped design a Twitter Streaming App using STORM and D3.js to monitor the programs Hashtags
Maintenance and servicing of various Electrical systems.
Completed "Scala Fundamentals: The Type System" a course on Pluralsight
Attained a BSc Electrical and Electronics Engineering (Second Class Honors)


ViewStyle
public final class ViewStyle: NSObject
The ViewStyle
defines style of any UIView
.
Can define color, tint, border, shadow and layer properties.
@see ViewStyle.Property
-
Create a new instance of
ViewStyle
using properties- Parametes properties: The array of properties
Declaration
Swift
public convenience init(_ properties: Property...)
Return Value
New instance of
ViewStyle
-
Applies self to given
UIView
Declaration
Swift
@objc public func apply(to view: UIView)
Parameters
view
The view on which to apply the style
-
Updates curent style with given properties. It uses right associativity rule thus if you redefine any of the original properties assigned to self it will ve overwritten by the new one
let red = ViewStyle(.backgroundColor(.red)) let redTint = red(.tintColor(.red))
Declaration
Swift
public func updating(_ other: Property...) -> ViewStyle
Parameters
properties
The array of
Property
to be added to the styleReturn Value
The instance of
ViewStyle
with combined properties -
Operator
+
combines two styles. It uses right associativity rule thus if both styles match any property the right will be used.Declaration
Swift
public static func +(left: ViewStyle, right: ViewStyle) -> ViewStyle
Parameters
left
The
ViewStyle
to be combined withright
right
The
ViewStyle
to be combined withleft
Return Value
The resulting
ViewStyle
containing bot properties fromleft
andright
-
Checks for equality of layer properties. If the defined layer properties does not match with otehr style the function throws an error. The layer properties has to match otherwise UI glitched may be created. If the error is thrown it contains a description which properties are missing.
Declaration
Swift
@objc public func hasEqualLayerProperties(_ other: ViewStyle) throws
Parameters
other
The view style to check for equal layer properties


{{task.note}}
Submitted by {{task.submitter_email}} on {{task.created_date | date}}. Assigned to {{user.username}}
Due: {{task.due_date | date}}


---
layout: post
title: Goldman Sachs executive compensation 18% higher than Q1 2008
date: 2009-04-15 09:01:53.000000000 -05:00
comments: true
categories:
- Finance
- the economy
published: true
---
So Goldman Sachs has officially released results for Q1 - 2009. They were significantly better than analysts' estimates. Surprise, surprise. Most intriguing though, are the details of their earnings. When they just announced the results they caught Wall Street by surprise and there was a rally, but it seems that something changed investors' minds. Either the $5B equity dilution they announced, or there is something else in their earnings report that investors are acting on. Let's look more closely at their numbers.
[caption id="" align="aligncenter" width="512" caption="Henry 'Hank' Paulson - Ex-CEO of Goldman"]
[/caption]
The breakdown is as follows:
Revenues
- Net Revenues of $9.43B, Net Earnings of $1.81B
- Diluted EPS of $3.39 vs $3.23 for Q1 - 2008 vs -$4.97 for Q4 - 2008.
- Diluted EPS of $3.39 beating the average analyst estimate by $1.64.
- Net Revenues in Investment Banking were $823M, 30% lower than Q1 - 2008
- Net Revenues in Financial Advisory were $527M, 21% lower than Q1 - 2008
- Net Revenus in Underwriting Business were $296M, 42% lower than Q1 - 2008
- Net Revenues in Trading & Principal Investments were $7.15B vs $5.12B for Q1 - 2008 & -$4.36B for Q4 - 2008
- Net Revenues in Fixed Income, Currency & Commodities (FICC) were $6.56B, more than double Q1 - 2008 (no figure given)
- Net Revenues in Equities were $2B, 20% lower than Q1 - 2008
- Net Revenues in Asset Management & Securities Services were $1.45B, 29% lower than Q1 - 2008 vs 17% lower than Q4 - 2008.
- Assets Under Management (AUM) decreased $27B to $771B, due to $16B market depreciation and $11B in net outflows.
- Net Revenues for Securities Services were $503M, 30% lower than Q1 - 2008.
Expenses
- Operating Expenses were $6.8B, 10% higher than Q1 - 2008.
-
Compensation & Benefits Expenses were $4.71B, 18% higher than Q1 - 2008.
- Ratio of Compensation & Benefits to Net Revenues increased to 50%, vs. 48% for Q1 - 2008.
- Employment levels decreased 7% compared with Q4 - 2008.
- Non-compensation expenses were $1.62B, 21% lower than Q1 - 2008 vs. 25% lower than Q4 - 2008.
- Effective Income Tax Rate was 31%, up from 1% for 2008 & 29.5% for Q1 - 2008 (this 1% figure makes sense due to all the write-offs and losses they took in 2008)
This is why accounting is so tricky. I am a bit confused. Their Fixed Income Assets actually decreased from $259B Q1 - 2008 to $248B Q1 - 2009, actually their total AUM decreased to $771B from $873B in Q1 2008. They had net (outflows) of $3B in Fixed Income as opposed to a Net Inflow of $2B in Q1 - 2008.
So the big question is, how on earth (in a quarter when the majority of all their streams of revenue declined) did they pull off revenues in Fixed Income Commodities & Currency doubling. FICC Revenues jumped from $3.14B in Q1 - 2008 to $6.557B in Q1 - 2009.
How is that possible, when their AUM across the board declined, and revenues across the board declined?
So their "revenues" increased, in a year when they took TARP money, raised private equity from the likes of Warren Buffet, and received a payout from AIG and they decided to increase executive compensation?
I am not saying that Goldman is doing fraudulent activity, but these results do raise some flags. It could be that I have misread something, or glanced over something glaringly obvious to the 'trained eye', and if that's the case please point out my error in the comments.
Click here to see where I got all the above info from.
What would be interesting to look into is if Paulson currently owns (or owns an interest in any fund/company) that owns Goldman stock. I am not really one to rally the troops and bring out the pitch forks, but sometimes I am most definitely tempted!


| CotsBots Setup
Last updated 31 Jan. 2003 |
There are a couple important setup parameters in using CotsBots that you
should read first before doing any CotsBots programming.
|
Programming the MotorBoard
|
Several things have changed since the MotorBoard was last programmed, so
it is important to do this first. The MotorBoard uses the ATmega8L
microcontroller, a relatively recent addition to the Atmel family. Therefore,
in order to program, you must be using avr-gcc3.2 or higher.
Please re-program your MotorBoards first! Many things have been
added since code was last downloaded to the motorboards.
You will notice that you may need to add a sensorboard in the
programming board stack as shown below. In addition, a 3V power supply
(available from Radio Shack) needs to be used while programming. This
is taken care of when using the latest mica2 programming board.
Because the CotsBots software is placed in the separate tinyos-1.x/contrib
directory, one small addition must be made if using a Makelocal file in your
standard tinyos-1.x/apps directory. You may be using this if you are
working on an IBM Thinkpad, where you need to set the extra -dlpt=3 flag. Just
modify the Makelocal file in tinyos-1.x/contrib/cotsbots/apps/ to be the
same as that in your primary apps directory.
If you would like to have external control of the robot (for the TestMotorBoard
and TestNavigation applications), you will need to use the RobotCmdGUI
provided in the tinyos-1.x/contrib/cotsbots/tools directory. Once again,
because the software is installed in the contrib directory, you will need
to modify your CLASSPATH environment variable. Often you need to be
a computer administrator to do this. Add the following directory to the
CLASSPATH.
{INSTALL DRIVE}/tinyos-1.x/contrib/cotsbots/tools;
And that should be it!
If you have problems with any of the above, please email:
cotsbots-help@millennium.berkeley.edu


Man who allegedly lured teen to her death in Queens arrested
by Eyewitness NewsJAMAICA, Queens (WABC) -- A young man has been charged in the death of 17-year-old woman whose body was found in Queens last week, and authorities believe he lured the victim to her death.
Tyler Caldwell, 20, is charged with conspiracy and criminal facilitation in the death of Talasia Cuffie, the godsister of 14-year-old Aamir Griffin, who was shot by a stray bullet while playing basketball last month in Jamaica.
Friends say Cuffie was at Griffin's home with his family after a celebration of his life, went out to get something to eat, and never came back.
Cuffie was then found on a sidewalk on 166th Street in South Jamaica with multiple stab wounds.
Police say there were signs of a struggle.
Cuffie was transported to Jamaica Hospital, where she was pronounced dead.
Other arrests are also expected, as detectives are still looking for the young woman believed to have fatally stabbed Cuffie, as well as that woman's boyfriend.
Police say Caldwell was ordered during multiple conversations with an unnamed person to lure Cuffie to 166th Street in Queens, where the woman and her boyfriend would confront her.
According to the criminal complaint, the woman told Caldwell, "I don't know if I should stab her or have my boyfriend shoot her."
Caldwell allegedly texted Cuffie on Friday night around 9 p.m. instructing her to go to 166th Street, where he knew the young woman and her boyfriend were waiting. They had called him, according to the complaint, directing him to send the victim to their location.
Cuffie was found later that night in a pool of her own blood with wounds to the lower abdomen and groin. She died soon after.
The next day, Caldwell allegedly met up with the two suspects and was told by the woman, "The (expletive) is dead. I poked her twice."
Her death does not appear to be linked to Griffin's shooting.
A vigil and march is scheduled in her memory Friday night.


Forecasting with modeltime.h2o
made easy! This short tutorial shows how you can use:
H2O AutoML for forecasting implemented via automl_reg()
. This function trains and cross-validates multiple machine learning and deep learning models (XGBoost GBM, GLMs, Random Forest, GBMs…) and then trains two Stacked Ensembled models, one of all the models, and one of only the best models of each kind. Finally, the best model is selected based on a stopping metric. And we take care of all this for you!
Save & Load Models functionality to ensure the persistence of your models.
Next, we load the walmart_sales_weekly
data containing 7 time series and visualize them using the timetk::plot_time_series()
function.
data_tbl <- walmart_sales_weekly %>%
select(id, Date, Weekly_Sales)
data_tbl %>%
group_by(id) %>%
plot_time_series(
.date_var = Date,
.value = Weekly_Sales,
.facet_ncol = 2,
.smooth = F,
.interactive = F
)
Then, we separate the data with the time_series_split()
function and generate a training dataset and a test one.
splits <- time_series_split(data_tbl, assess = "3 month", cumulative = TRUE)
recipe_spec <- recipe(Weekly_Sales ~ ., data = training(splits)) %>%
step_timeseries_signature(Date)
train_tbl <- training(splits) %>% bake(prep(recipe_spec), .)
test_tbl <- testing(splits) %>% bake(prep(recipe_spec), .)
In order to correctly use modeltime.h2o, it is necessary to connect to an H2O cluster through the h2o.init()
function. You can find more information on how to set up the cluster by typing ?h2o.init
or by visiting the official site.
# Initialize H2O
h2o.init(
nthreads = -1,
ip = 'localhost',
port = 54321
)
#>
#> H2O is not running yet, starting it now...
#>
#> Note: In case of errors look at the following log files:
#> /var/folders/st/s5vwv9pd27g7z2sffwlqmtv80000gn/T//RtmpOAzLqf/file60373f953c09/h2o_mdancho_started_from_r.out
#> /var/folders/st/s5vwv9pd27g7z2sffwlqmtv80000gn/T//RtmpOAzLqf/file60375e98937b/h2o_mdancho_started_from_r.err
#>
#>
#> Starting H2O JVM and connecting: ... Connection successful!
#>
#> R is connected to the H2O cluster:
#> H2O cluster uptime: 2 seconds 616 milliseconds
#> H2O cluster timezone: America/New_York
#> H2O data parsing timezone: UTC
#> H2O cluster version: <IP_ADDRESS>
#> H2O cluster version age: 5 months and 27 days !!!
#> H2O cluster name: H2O_started_from_R_mdancho_ueg906
#> H2O cluster total nodes: 1
#> H2O cluster total memory: 8.00 GB
#> H2O cluster total cores: 12
#> H2O cluster allowed cores: 12
#> H2O cluster healthy: TRUE
#> H2O Connection ip: localhost
#> H2O Connection port: 54321
#> H2O Connection proxy: NA
#> H2O Internal Security: FALSE
#> H2O API Extensions: Amazon S3, XGBoost, Algos, AutoML, Core V3, TargetEncoder, Core V4
#> R Version: R version 4.0.2 (2020-06-22)
# Optional - Set H2O No Progress to remove progress bars
h2o.no_progress()
Now comes the fun part! We define our model specification with the automl_reg()
function and pass the arguments through the engine:
model_spec <- automl_reg(mode = 'regression') %>%
set_engine(
engine = 'h2o',
max_runtime_secs = 5,
max_runtime_secs_per_model = 3,
max_models = 3,
nfolds = 5,
exclude_algos = c("DeepLearning"),
verbosity = NULL,
seed = 786
)
model_spec
#> H2O AutoML Model Specification (regression)
#>
#> Engine-Specific Arguments:
#> max_runtime_secs = 5
#> max_runtime_secs_per_model = 3
#> max_models = 3
#> nfolds = 5
#> exclude_algos = c("DeepLearning")
#> verbosity = NULL
#> seed = 786
#>
#> Computational engine: h2o
Next, let’s train the model with fit()
!
model_fitted <- model_spec %>%
fit(Weekly_Sales ~ ., data = train_tbl)
#> model_id mean_residual_deviance
#> 1 StackedEnsemble_AllModels_AutoML_20210405_115904 38501320
#> 2 XGBoost_3_AutoML_20210405_115904 42212631
#> 3 XGBoost_2_AutoML_20210405_115904 58816361
#> 4 XGBoost_1_AutoML_20210405_115904<PHONE_NUMBER>
#> rmse mse mae rmsle
#> 1 6204.943 38501320 3835.035 0.1444437
#> 2 6497.125 42212631 4096.153 0.1501578
#> 3 7669.183 58816361 4875.643 0.1673720
#> 4 48675.137<PHONE_NUMBER> 40066.038 1.2850293
#>
#> [4 rows x 6 columns]
model_fitted
#> parsnip model object
#>
#> Fit time: 9s
#>
#> H2O AutoML - Stackedensemble
#> --------
#> Model: Model Details:
#> ==============
#>
#> H2ORegressionModel: stackedensemble
#> Model ID: StackedEnsemble_AllModels_AutoML_20210405_115904
#> Number of Base Models: 3
#>
#> Base Models (count by algorithm type):
#>
#> xgboost
#> 3
#>
#> Metalearner:
#>
#> Metalearner algorithm: glm
#> Metalearner cross-validation fold assignment:
#> Fold assignment scheme: AUTO
#> Number of folds: 5
#> Fold column: NULL
#> Metalearner hyperparameters:
#>
#>
#> H2ORegressionMetrics: stackedensemble
#> ** Reported on training data. **
#>
#> MSE: 22728954
#> RMSE: 4767.489
#> MAE: 3027.272
#> RMSLE: 0.1026567
#> Mean Residual Deviance : 22728954
#>
#>
#>
#> H2ORegressionMetrics: stackedensemble
#> ** Reported on cross-validation data. **
#> ** 5-fold cross-validation on training data (Metrics computed for combined holdout predictions) **
#>
#> MSE: 38501320
#> RMSE: 6204.943
#> MAE: 3835.035
#> RMSLE: 0.1444437
#> Mean Residual Deviance : 38501320
The best models are stored in the leaderbord
and by default the one with the best metric with which you have decided to sort the leaderbord is selected (this behavior can be controlled with the sort_metric
parameter passed through set_engine. For more information see ?h2o.automl. By default, it is sorted by the mean_residual_deviance). To list the models created during training that have finally been stored in the leaderbord you can use the automl_leaderbord
function as follows:
automl_leaderboard(model_fitted)
#> # A tibble: 4 x 6
#> model_id mean_residual_devi… rmse mse mae rmsle
#> <chr> <dbl> <dbl> <dbl> <dbl> <dbl>
#> 1 StackedEnsemble_AllModels_Au… 38501320. 6205. 3.85e7 3835. 0.144
#> 2 XGBoost_3_AutoML_20210405_11… 42212631. 6497. 4.22e7 4096. 0.150
#> 3 XGBoost_2_AutoML_20210405_11… 58816361. 7669. 5.88e7 4876. 0.167
#> 4 XGBoost_1_AutoML_20210405_11…<PHONE_NUMBER>. 48675. 2.37e9 40066. 1.29
To change the default selected model (remember, the first one sorted according to the selected metric) you can do it with the automl_update_model()
function as follows (do not run the following example as the model id name will have changed as there is randomness in the process):
automl_update_model(model_fitted, model_id = "StackedEnsemble_AllModels_AutoML_20210319_204825")
Finally, we predict()
on the test dataset:
predict(model_fitted, test_tbl)
#> # A tibble: 84 x 1
#> .pred
#> <dbl>
#> 1 19438.
#> 2 31548.
#> 3 37335.
#> 4 40876.
#> 5 77931.
#> 6 79811.
#> 7 132721.
#> 8 19065.
#> 9 36439.
#> 10 36364.
#> # … with 74 more rows
Once we have our fitted model, we can follow the Modeltime Workflow:
Add fitted models to a Model Table.
Calibrate the models to a testing set.
Perform Testing Set Forecast Evaluation & Accuracy Evaluation.
Refit the models to Full Dataset & Forecast Forward
First, we create the model table:
modeltime_tbl <- modeltime_table(
model_fitted
)
modeltime_tbl
#> # Modeltime Table
#> # A tibble: 1 x 3
#> .model_id .model .model_desc
#> <int> <list> <chr>
#> 1 1 <fit[+]> H2O AUTOML - STACKEDENSEMBLE
Next, we calibrate to the testing set and visualize the forecasts:
modeltime_tbl %>%
modeltime_calibrate(test_tbl) %>%
modeltime_forecast(
new_data = test_tbl,
actual_data = data_tbl,
keep_data = TRUE
) %>%
group_by(id) %>%
plot_modeltime_forecast(
.facet_ncol = 2,
.interactive = FALSE
)
Before using refit on our dataset, let’s prepare our data. We create data_prepared_tbl
which represents the complete dataset (the union of train and test) with the variables created with the recipe named recipe_spec. Subsequently, we create the dataset future_prepared_tbl
that represents the dataset with the future data to one year and the required variables.
data_prepared_tbl <- bind_rows(train_tbl, test_tbl)
future_tbl <- data_prepared_tbl %>%
group_by(id) %>%
future_frame(.length_out = "1 year") %>%
ungroup()
future_prepared_tbl <- bake(prep(recipe_spec), future_tbl)
Finally, we use forecast in our future dataset and visualize the results once we had reffited.
refit_tbl <- modeltime_tbl %>%
modeltime_refit(data_prepared_tbl)
#> model_id mean_residual_deviance
#> 1 StackedEnsemble_AllModels_AutoML_20210405_115918 45119504
#> 2 XGBoost_2_AutoML_20210405_115918 128393878
#> 3 XGBoost_1_AutoML_20210405_115918 156236498
#> 4 XGBoost_3_AutoML_20210405_115918 265914814
#> rmse mse mae rmsle
#> 1 6717.105 45119504 4409.966 0.1535976
#> 2 11331.102 128393878 7725.048 0.1921754
#> 3 12499.460 156236498 8734.104 0.2435574
#> 4 16306.895 265914814 11719.747 0.2776191
#>
#> [4 rows x 6 columns]
refit_tbl %>%
modeltime_forecast(
new_data = future_prepared_tbl,
actual_data = data_prepared_tbl,
keep_data = TRUE
) %>%
group_by(id) %>%
plot_modeltime_forecast(
.facet_ncol = 2,
.interactive = FALSE
)
We can likely do better than this if we train longer but really good for a quick example!
H2O models will need to “serialized” (a fancy word for saved to a directory that contains the recipe for recreating the models). To save the models, use save_h2o_model()
.
model_fitted %>%
save_h2o_model(path = "../model_fitted", overwrite = TRUE)
You can reload the model into R using load_h2o_model()
.
model_h2o <- load_h2o_model(path = "../model_fitted/")
Finally, once we have saved the specific models that we want to keep, we shutdown the H2O cluster.
h2o.shutdown(prompt = FALSE)
Need to learn high-performance time series forecasting?
Become the forecasting expert for your organization
High-Performance Time Series Course
Time series is changing. Businesses now need 10,000+ time series forecasts every day. This is what I call a High-Performance Time Series Forecasting System (HPTSF) - Accurate, Robust, and Scalable Forecasting.
High-Performance Forecasting Systems will save companies by improving accuracy and scalability. Imagine what will happen to your career if you can provide your organization a “High-Performance Time Series Forecasting System” (HPTSF System).
I teach how to build a HPTFS System in my High-Performance Time Series Forecasting Course. You will learn:
Modeltime
- 30+ Models (Prophet, ARIMA, XGBoost, Random Forest, & many more)GluonTS
(Competition Winners)Become the Time Series Expert for your organization.


core API¶
Core : Functions useful for all the package.¶
-
class
music22.core.
f0file
(path)[source]¶ A class to manage data files (.txt).
-
class
music22.core.
file
(path)[source]¶ A class to manage files.
Paramètres: path (str) – absolute path of a file. -
path
¶ str
The path of the file.
-
basename
¶ str
The name of the file.
-
dirname
¶ str
The directory path of the file.
-
name
¶ str
The name of the file.
-
extension
¶ str
The extension of the file.
Example
>>> audio = "/Users/anas/Barraq/AUDIO/P0.wav" >>> A = file(audio) >>> print A.path /Users/anas/Barraq/AUDIO/P0.wav >>> print A.basename P0.wav >>> print A.dirname /Users/anas/Barraq/AUDIO >>> print A.name P0 >>> print A.extension wav
-


Name
Email
Phone
Name
Email
Phone
Actions
{{contact.name}}
{{contact.email}}
{{contact.phone}}
Edit
Delete


Selecting Constructor
To select constructors you create through the Unity container, you can use the following three techniques:
Automatic Constructor Injection. With this technique, you allow the Unity container to select a constructor and to satisfy any constructor dependencies defined in parameters of the constructor automatically. For more information see Automatic Constructor Selection.
Constructor Injection using explicit registration. With this technique, you register the Type and apply an Injection Constructor Member that specifies the dependencies to the registration. For more information see Constructor Injection
Annotated Constructor Injection. With this technique, you apply InjectionConstructor attribute to one of the class constructors to designate it to be used to instantiate an instance.
Annotated Constructor Injection
Constructor Injection with Attribute Annotation allows you to apply attributes to the class' constructor designating it for dependency injection. When creating the class, Unity will always (unless explicitly overwritten in Registration) use that constructor. You only need to use this technique when there is more than one constructor in the target type.
Annotating a Constructor
When a target class contains more than one constructor and the automatic algorithm does not provide desired selection, you may use the InjectionConstructor attribute to specify the constructor you wish to use for injection.
Consider the following Type:
public class Service
{
public Service() => Ctor = 1;
[InjectionConstructor]
public Service(object arg) => Ctor = 2;
public Service(IUnityContainer container) => Ctor = 3;
public Service(object[] data) => Ctor = 4;
public int Ctor { get; } // Constructor called
}
In this example type Service
contains four public constructors. Three of these constructors have one parameter each. A Type like this creates an ambiguity that Unity could not resolve by itself.
Warning
During resolution, the container will pick the first constructor it could satisfy with dependencies and will use it. In the example above, it could be any of the three constructors with one parameter.
The container is not trying to validate all available contractors during normal execution.
Note
If Diagnostic extension is enabled, Unity will throw an exception reporting ambiguous constructors.
Normally, Unity would select the third constructor with three parameters, but by annotating the second constructor with the attribute you force Unity to use it during resolution.
Multiple Constructor Annotations
Annotating multiple constructors with injection parameters is not recommended. Unity is not guaranteed to process constructors in certain order. If multiple constructors are annotated, behavior might change from version to version.
Note
If Diagnostic extension is enabled, Unity will throw an exception reporting ambiguous constructor annotations.


I'm a software engineer in the Atlanta, GA area. My professional
background is mostly in C# and Java
enterprise applications. My side projects range from client and
server side JavaScript work with
AngularJS and
Node.js to C
based projects for the Pebble
smart watch.
Want to get in touch or learn more?