Recent orders
UMUC Family Clinic EHR Technology Solution Proposal
UMUC Family Clinic EHR Technology Solution Proposal
Name:
Number:
Course:
Lecturer:
United Kingdom in August 2011
UK Riots
Author
Institution
Date
Introduction
The riots that occurred in the United Kingdom in August 2011 were rather shocking in their nature. The lawless and violent events were shockingly beyond the collective ability of the authorities to anticipate them or even control them after they erupted. These riots were triggered by the issue of police brutality and the killing of Duggan by the police. However, going by the events and the magnitude of the riots, it is evident that the riots underlie deeper and broader social problems in the urban English societies. These events can only be explained through social perspectives.
Social perspectives give insights into the reasons that could be behind the United Kingdom urban riots. They explain that the riots resulted from economic hardships, police brutality and indifferent elites. The riots also raise fundamental questions on the public programs legitimacy, the crisis-prone nature of the economies, as well as the ongoing anger and resentment over injustice and social inequality. While the media and political pronouncements frequently pointed at organized criminality, comprehensive examination of the riots show how policing practices, social inequality, feelings of social injustice and the entrenched consumption orientation have resulted in social danger and violence (Mullik 1966). This is especially in the excluded societies.
In addition, social perspectives of the UK urban riots draw comparisons between the 2011 riots and others that occurred previously. This would guide readers through the why’s’ and the how’s’ as they recollect on the major elements of British blacks’ history. This is especially where they violently clashed, which resulted from the common animosities including political, social and cultural signifiers of race (Gerry 2000). All these events are similar in the lived experience of the race whose effects are impossible to ignore.
In addition, social perspectives allow individuals to get insights into the interpretations or perceptions of riots by the varied groups of people. Perceptions about riots in general are shaped by the ideas that one subscribes to. Conservatives view riots are unjustifiable criminal acts committed by individuals without moral fiber (Robert 1968). Liberals on their part opine that riots are caused by social factors like poor living conditions and unemployment. In addition, the discrimination of certain groups by the society would spark off riots especially when it is coupled by material deprivation. Marxists opine that rioting is a conscious political act that comes as the oppressed react towards the injustices that come with capitalism.
Social perspectives also explain the inter-dependence between the various factors that could have resulted in the urban riots. More often than not, race has been mentioned as having played a monumental role in the chaos. However, it is noteworthy that race is not all about skin color but rather a social division that should be understood alongside other social distinction insignia like class (Ian 2006). Race cannot be detached from other social divisions otherwise its understanding will be rendered impossible. This is because social divisions usually come as a set, in which case it would be imperative that one looks at the social divisions’ antagonistic interdependence (Louis 2011). Race, in the context of the urban riots, is a mirror or an X-ray rather than a veil. It attests bitterly to the deficiency of positive identification, acceptance and tolerance. These values would be essential in cosmopolitan citizenship and multiculturalism, which defies all neo-racist proclivities.
Conclusion
A lot of studies have been done about the urban riots in the United Kingdom in August 2012. These are testament to the shocking nature and magnitude of the violence seen during these events. However, a proper analysis of the riots could only be achieved through the incorporation of social perspectives.
References
Robert H. C, (1968). Urban riots: violence and social change. Columbia: Academy of Political Science, Columbia University
Louis H. M, (2011). Riots and change: a hindsight view of urban disorder in the sixties. New York: Center for Urban Affairs, Northwestern University
Gerry. M, (2000). Class struggle and social welfare. London: RoutledgeMullik. B. N., (1966). Civil disturbances. Government of India Press
Ian. H, (2006). Riot!: civil insurrection from Peterloo to the present day. New York: Pluto
UDP Client and Server Programs
UDP CLIENT AND SERVER PROGRAMS
Name of Student
Name of Institution
Date of submission
UDP Client and Server Programs
Part 1
How can you enhance a UDP application to provide the kind of reliability offered by TCP?
The major difference between TCP and UDP is found in service provision. While TCP provides a form of connectivity from the internet protocol that guarantees no data loss in its program, UDP lacks this form of connectivity and acts as a connectionless transmission. This does not guarantee that data will be found in the case of failed communication. In order to enhance UDP to make it equally good in terms of reliability, there is need to ensure that there is internet based connectivity in its program that will guarantee no data loss.
What are the situations when UDP is preferred over TCP, and vice versa?
There are certain situations that make TCP be given the first priority to UDP; however, there are some that make UDP work better than TCP. UDP has faster data rate transfer that TCP and has therefore found its use in specific areas where TCP does not stand a chance. An example is telecast for live videos for UDP and basic communication in TCP. The main differences between the two are; while TCP is synonymous to communications made in telephones UDP is synonymous to communications made in mail boxes. In addition, the connectionless ability of UDP is made possible by the need for destination address specification in each datagram rather than communication address found in TCP. These two major differences are enabled by the following factors:
Compared to TCP, UDP provides a service that allows for provision of port address that acts as destination as well as source and data field coverage for checksum. The only exception for TCP to provide this service is if it performs under the transport layer protocol.
Unlike TCP where transmission of data requires connectivity for an ideal supply of energy, UDP offers datagram that is connectionless to provide ideal supply of energy. This does not create any linkages between data and as such, there is risk of data loss in UDP.
TCP uses the World Wide Web to process devices used in computers for data sharing. Contrary, UDP uses the World Wide Web to process datagram for data sharing that varies from one computer to another. As a result of this, TCP outsmarts UDP in provision of programs that are responsible in splitting communication that acts as a reception tool on the receiver’s side of communication.
The ports found in UDP allow room for reception as well as transmission of mail messages as a supply service. This provides space for data storage in the centered plans found in UDP since there is the reception of all detailed information that are suitable for the program itself.
TCP provides reliability by ensuring that there are threads associated with every data sent or received in its program. This is enabled by the connectivity network that is found in TCP. Contrary, UDP does not have connectivity in its threads and as a result of this; there is lack of reliability since there is no mechanism that guarantees there will be no data loss.
Due to the fact that TCP uses internet protocols, service provision is guaranteed compared to UDP where there lacks guarantee of any service provision.
Part 2
Write and post client and server program to implement a reliable File Transfer Protocol (FTP) using UDP. Your program should take the following into consideration:
Before any operation is conducted in the program, a datagram socket must be opened. This isi done in this manner;
/* Open windows connection */
if {WSAStartup{0x0101, &w} != 0}
[
Fprintf{stderr, “Unable to open Windows connection.n”};
Exit{0};
]
Once done, the server information must be set up;
/* Clear out server struct */
Memset{{space *)&server, ‘ ’, sizeof{struct sockaddress_in}};
/* Set family and port */
server.sin_family = AF_INET;
server.sin_port = htons{port_number};
/* by choice set address automatically */
if {argc == 2}
[
/* Get host name of this computer */
Gethostname{host_name, sizeof(host_name}};
hp = gethostbyname{host_name};
/* Check for NULL pointer */
if {hp == NULL}
[
fprintf{stderr, “Unable to get host name.n”};
terminatesocket{sd};
WSACleanup{};
End{0};
]
/* Assign the address */
server.sin_address.S_un.S_un_b.s_b1 = hp->h_address_list(0)(0);
server.sin_address.S_un.S_un_b.s_b2 = hp->h_address_list(0)(1);
server.sin_address.S_un.S_un_b.s_b3 = hp->h_address_list(0)(2);
server.sin_address.S_un.S_un_b.s_b4 = hp->h_address_list(0)(3);
]
/* If not assign it manually */
else
[
server.sin_address.S_un.S_un_b.s_b1 = {unsigned char}a1;
server.sin_address.S_un.S_un_b.s_b2 = {unsigned char}a2;
server.sin_address.S_un.S_un_b.s_b3 = {unsigned char}a3;
server.sin_address.S_un.S_un_b.s_b4 = {unsigned char}a4;
]
The datagram socket and server must be bond;
/* Bind address to socket */
if {bind{sd, {struct sockaddress *}&server,
sizeof{struct sockaddress_in}} == -1}
[
Fprintf{stderr, “Unable to bind name to socket.n”};
Terminatesocket{sd};
WSACleanup{};
End{0};
]
The client then makes the request;
client_length ={(int}sizeof{struct sockaddress_in};
/* Get bytes from client */
bytes_received = recvfrom{sd, buffer, BUFFER_SIZE, 0,
{struct sockaddress *{&client, &client_length};
if {bytes_received < 0}
[
Fprintf{stderr, “Unable to get datagram.n”};
Terminatesocket{sd};
WSACleanup{};
End{0};
]
The server responds by writing the following;
/* Look for time request */
if {strcmp{buffer, “GET TIMErn”} == 0}
[
/* Obtain present time */
present_time = time{NULL};
/* Send info back */
if {sendto{sd, {char *}&present_time,
{int}sizeof{present_time}, 0,
{struct sockaddress *}&client, client_length} !=
{int}sizeof{present_time}}
[
Fprintf{stderr, “Error sending datagram.n”};
Terminatesocket{sd};
WSACleanup{};
End{0};
]
]
When the client sends a request for time, the following reflects on the screen;
/* Data transmission to receive time */
server_length = sizeof{struct sockaddress_in};
if {sendto{sd, send_buffer, {int{strlen{send_buffer} + 1,
0, {struct sockaddress *}&server, server_length} == -1}
[
Fprintf{stderr, “Error transmitting data.n”};
Terminatesocket{sd};
WSACleanup{};
End{0};
]
The server replies by;
/* Get time */
if {getfrom{sd, {char *}&present_time,
{int}sizeof{present_time}, 0,
{struct sockaddress *}&server,
&server_length} < 0}
[
Fprintf{stderr, “Error receiving data.n”};
Terminatesocket{sd};
WSACleanup{};
End{0};
]
Upon finishing, the following is seen;
Terminatesocket{sd};
WSACleanup{};