Lesson 2: Python basics
In this lesson we will explore the basics of Python and learn to work in Jupyter notebooks (formerly known as iPython or interactive Python notebooks).
Why Python?
Python has quickly risen in popularity among programmers and scientists alike. It is a relatively new language compared to heavy-hitters like C and JAVA, but it will soon be the third most popular programming language. One of the main reasons Python has become so popular is that it is relatively easy to read and learn. Python was designed to put style and readability first, making it easier to pick up for beginners. It is also quite intuitive (at least for English speakers), as many programs you write will read almost word-for-word as you would describe them in plain English. This is not to say that learning the ins-and-outs of Python is easy. Like any language, it takes a lot of practice to master.
Two other reasons we use Python is because it is free and well supported. A large community has grown around developing excellent open-source (free) code for Python. Many well-tested packages for scientific analysis, image processing, and machine learning have been written specifically for Python and are freely available to the public. A good portion of this course will focus on finding, installing, and managing Python packages with Anaconda to take advantage of the huge body of open source code that you can apply to your research.
Jupyter (iPython notebooks)
The Jupyter Notebook is an interactive document that combines text and code. By the end of this course, you will be able to write up something to the effect of this and post it to GitHub so that anyone can view your data, code, and reproducible results.
For now, we’ll use a cool website called mybinder that not only allows you to view Jupyter notebooks, but also allows you to interactively run the code inside them. This is a new and exciting way that scientists can share their analysis in a truly transparent and reproducible way.
The two main parts of this lesson are exercises in interactive Jupyter notebooks. The first part is a quick tutorial on Jupyter notebooks and how to use them. Feel free to play around until you are comfortable.
The second part of this lesson is practice with some basic Python. You are given several functions in a Jupyter notebook that deal with strings, booleans, and if statements. You will need to fix and run the code in the notebook until the functions work as intended.
The rest of this document involves getting Jupyter running locally and also remotely via ssh. Some of the configuration details are a little technical, but hopefully once you have it set up, you will be able to create, edit, and interact with Jupyter notebooks to start making reproducible scientific code.
Starting a local Jupyter server
Websites like mybinder.org are great for sharing Jupyter notebooks online, but they are limited by the resources the website will allow you. Luckily, Jupyter comes with an easy way to start a local server, so that you can quickly create and test your notebooks on your computer.
Starting Jupyter locally (no ssh)
Jupyter is installed by default with Anaconda. On any Linux or Mac computer with Anaconda installed, you can type jupyter notebook
into the shell and wait for it to start running. Your shell should print out info as it configures the local server. When it is ready, you should see a line with a url starting with http://localhost
. This means that your local server is running, and you can access it by navigating to that link in a web browser (the Jupyter team recommends Mozilla Firefox or Google Chrome).
jupyter notebook
# A bunch of setup lines
[I 11:59:16.597 NotebookApp] The Jupyter Notebook is running at:
http://localhost:8888/?token=c8de56fa4deed24899803e93c227592aef6538f93025fe01
You should see a plain Jupyter
splash page. If you do, great! Skip to Navigating the Jupyter Server.
Starting Jupyter remotely (with ssh)
If you are writing and running code on a remote computer (where Anaconda is installed), the steps above will still work as long as you use the graphical flag ssh -X
or ssh -Y
when you connect to the remote machine. The problem you would have is the web browser that opens will be very slow to type in because it needs to send a picture of the whole screen over the internet every time you type a character.
What we want is to start the Jupyter server on the remote machine (so we can edit and run our code there), but to see the server with a web browser on our local computer. This part is a little technical, but at the end of it you will have two simple scripts that:
1) Start the Jupyter server on the remote computer
2) Connect a local port on your computer to the remote server so that you can see the Jupyter server in a web browser on your local computer.
Starting Jupyter (on the remote computer)
First access your remote computer with ssh.
Next, we need to start Jupyter on the remote server with the Jupyter notebook
command with two extra flags. The --no-browser
flag stops Jupyter from trying to open a browser on the remote machine, while the --port
flag starts the server on a specific port.
On the remote computer:
jupyter notebook --no-browser --port=8080
Note: Leave this shell running! if you close this shell, it will kill the Jupyter server.
Connecting to Jupyter (from the local computer)
On Linux/Mac:
We will use a second ssh to our remote computer to connect a local port to the port we started Jupyter on above. This is called port forwarding. Open a new shell/terminal on our local computer.
In a new shell on your local computer:
ssh -v -N -L 8080:localhost:8080 <YOUR_SSH_USER>@<REMOTE_HOST>
This works the same as your regular ssh and you will need to log in. Once you have, your local port 8080 should be forwarded to the remote computer’s port 8080. Now you can open a browser and navigate to localhost:8080
and you should see the Jupyter
server running on the remote machine.
On Windows
If on Windows, you have a couple options for connecting to your remote Jupyter server.
Using the Windows Subsystem for Linux, the above commands for Linux/Mac should work in your Windows bash shell.
Using PuTTY, we will need to configure port-forwarding before we remote login to the remote server. Assuming you are comfortable with PuTTY and can ssh into the remote machine, below are the additional steps you will need to take:
1) Open PuTTY Settings / Configuration
2) On the left menu, go to SSH then Tunnels
3) Enter 8080 as your Source port
4) Enter <IP_ADDRESS>:8080 as your Destination
5) Click Add, then Open your connection to the remote machine.
Now on the remote machine, start the Jupyter server as above. Finally, you should be able to open Chrome or Firefox on Windows, head to localhost:8080
and see the remote Jupyter
server.
If you’re having trouble finding the settings, there are pictures and a guide on port forwarding with PuTTY here.
Creating scripts to simplify the above
The above two commands would be a pain to run every time we want to open a Jupyter notebook. Luckily we know from previous lessons how to simplify our lives by making executable bash scripts!
startjupyter script (to start Jupyter remotely)
Ssh to your remote machine.
Create a directory in your home directory called bin/
. The bin or binaries directory is where executable scripts on your computer are saved. We will reserve this home/bin/
directory to store our own user defined scripts (to keep them separate from operating system scripts).
mkdir ~/bin
Create a file in the ~/bin
directory called startjupyter
. Copy the command we used to start the notebook server into the file. Don’t forget the shebang (#!/bin/bash
)!
#!/bin/bash
jupyter notebook --no-browser --port=8080
Make the startjupyter
script executable with chmod u+x
.
chmod u+x ~/bin/startjupyter
Add the ~/bin
directory to your PATH
by adding the following to your .bash_profile
.
# Added path to my scripts to system PATH
export PATH=$PATH:/home/<your_username>/bin
Source your .bash_profile
so that the change takes effect.
source ~/.bash_profile
Now you can start a Jupyter server from anywhere on your remote machine by typing startjupyter
.
Mac/Linux: connectjupyter script (to connect local port to remote Jupyter server)
Open a new shell/Terminal on your local computer.
Create a directory in your home directory called bin/
. Again, this is where you can store your local shell scripts.
mkdir ~/bin
Create a file in the ~/bin
directory called connectjupyter
. This time we will make a slightly more general script. Copy the following into connectjupyter
. Make sure to replace <YOUR_SSH_ID>@<REMOTE_HOST>
with your personal ssh info.
#!/bin/bash
remoteport=${1:-8080}
localport=${2:-8080}
ssh -v -N -L ${localport}:localhost:${remoteport} <YOUR_SSH_ID>@<REMOTE_HOST>
Make connectjupyter
executable with chmod +x
.
chmod +x ~/bin/connectjupyter
Add the ~/bin
directory to your PATH
by adding the following to your .bashrc
(Linux) or your .bash_profile
(Mac).
# Addded path to my scripts to system PATH
export PATH=$PATH:/home/<your_username>/bin
Source your .bashrc
(Linux) or your .bash_profile
(Mac) so that the change takes effect.
source ~/.bashrc # or ~/.bash_profile
Now you can connect to your remote Jupyter environment from your local shell/Terminal with the connectjupyter
command! Make sure to run startjupyter
on the remote machine first!
Note on ports: connectjupyter
will default to connecting the local port 8080 to the remote port 8080. Make sure when you run startjupyter
on your remote machine that it is directing you to localhost:8080
. If for some reason this port was taken, your server will be opened on the next available port and you will see something like:
startjupyter
# A bunch of setup lines
[I 11:59:16.597 NotebookApp] The Jupyter Notebook is running at:
http://localhost:8081/?token=c8de56fa4deed24899803e93c227592aef6538f93025fe01
If this is the case, you need to direct your local port to the remote port 8081
. You can specify a remote port in the connectjupyter
script by adding it as the first option (e.g. connectjupyter 8081
). Then when you go to localhost:8080
on your local machine, you will be able to see the Jupyter server.
If you prefer to make both ports the same for simplicity, you can also use the second option to connect jupyter
, (e.g. connectjupyter 8081 8081
). Now you need to go to localhost:8081
to see the remote Jupyter server.
Windows
On Windows, your PuTTY tunneling configuration should be saved and will execute each time, no need for a connectjupyter
script. One hiccup is if you are sharing a machine among several people who may be opening servers on ports, you may not be guaranteed 8080
. In this case, I suggest picking a new port number somewhere in the range of 8070-8079
that nobody else uses. You will need to update your startjupyter
script to open on your chosen port --port=807X
, and then update your Destination=<IP_ADDRESS>:807X
accordingly in PuTTY.
Navigating the Jupyter Server
Now that you were able to start the local Jupyter server, you can start creating and editing Jupyter notebooks! If the splash page prompts you to log in, return to the shell where you started the server and find the token
, a random string of characters after ?token=
. Copy and paste this into the password field.
Now you should see the directory where you started the notebook. From here you can navigate your file-system. When you are in the folder you want, you can click New -> Python 3
to start a new Jupyter notebook. You can also click on an .ipynb
file to open it for editing.
You can stop a Jupyter server at any time by returning to the shell where it is running and typing ctrl+c
. Make sure to save your work first!
That’s it!
Once you have completed the two Jupyter tutorials and got a Jupyter server running, you are finished for today! The Jupyter server configuration can be a bit tough, if you need a hand please let me know!
Next class, we will be learning how to work with lists and dictionaries as well as how to write functions.
Reminder that the pre-class homework for next lesson is Codecademy’s Learn-Python modules 4 and 5.


@@include("partials/head.html") @@include("partials/header.html")
Thank you! I'll be reaching out to you soon.
Follow @queryinterviews or sign up for our newsletter.
← Back to the homepage


NC
Section: User Commands (1)Index Return to Main Contents
BSD mandoc
NAME
nc - arbitrary TCP and UDP connections and listensSYNOPSIS
nc -words [-46DdhklnrStUuvzC ] [-i interval ] [-p source_port ] [-s source_ip_address ] [-T ToS ] [-w timeout ] [-X proxy_protocol ] [ -x proxy_address [: port ] ] [hostname ] [port Bq s ]DESCRIPTION
The nc (or netcat utility is used for just about anything under the sun involving TCP or UDP. It can open TCP connections, send UDP packets, listen on arbitrary TCP and UDP ports, do port scanning, and deal with both IPv4 and IPv6. Unlike telnet(1), nc scripts nicely, and separates error messages onto standard error instead of sending them to standard output, as telnet(1) does with some.Common uses include:
- simple TCP proxies
- shell-script based HTTP clients and servers
- network daemon testing
- a SOCKS or HTTP ProxyCommand for ssh(1)
- and much, much more
The options are as follows:
- -4
- Forces nc to use IPv4 addresses only.
- -6
- Forces nc to use IPv6 addresses only.
- -D
- Enable debugging on the socket.
- -d
- Do not attempt to read from stdin.
- -h
- Prints out nc help.
- -i interval
- Specifies a delay time interval between lines of text sent and received. Also causes a delay time between connections to multiple ports.
- -k
- Forces nc to stay listening for another connection after its current connection is completed. It is an error to use this option without the -l option.
- -l
- Used to specify that nc should listen for an incoming connection rather than initiate a connection to a remote host. It is an error to use this option in conjunction with the -p -s or -z options. Additionally, any timeouts specified with the -w option are ignored.
- -n
- Do not do any DNS or service lookups on any specified addresses, hostnames or ports.
- -p source_port
- Specifies the source port nc should use, subject to privilege restrictions and availability. It is an error to use this option in conjunction with the -l option.
- -r
- Specifies that source and/or destination ports should be chosen randomly instead of sequentially within a range or in the order that the system assigns them.
- -S
- Enables the RFC 2385 TCP MD5 signature option.
- -s source_ip_address
- Specifies the IP of the interface which is used to send the packets. It is an error to use this option in conjunction with the -l option.
- -T ToS
- Specifies IP Type of Service (ToS) for the connection. Valid values are the tokens ``lowdelay'' ``throughput'' ``reliability'' or an 8-bit hexadecimal value preceded by ``0x''
- -C
- Send CRLF as line-ending
- -t
- Causes nc to send RFC 854 DON'T and WON'T responses to RFC 854 DO and WILL requests. This makes it possible to use nc to script telnet sessions.
- -U
- Specifies to use Unix Domain Sockets.
- -u
- Use UDP instead of the default option of TCP.
- -v
- Have nc give more verbose output.
- -w timeout
- If a connection and stdin are idle for more than timeout seconds, then the connection is silently closed. The -w flag has no effect on the -l option, i.e. nc will listen forever for a connection, with or without the -w flag. The default is no timeout.
- -X proxy_version
- Requests that nc should use the specified protocol when talking to the proxy server. Supported protocols are ``4'' (SOCKS v.4), ``5'' (SOCKS v.5) and ``connect'' (HTTPS proxy). If the protocol is not specified, SOCKS version 5 is used.
- -x proxy_address [: port ]
-
- Requests that nc should connect to hostname using a proxy at proxy_address and port If port is not specified, the well-known port for the proxy protocol is used (1080 for SOCKS, 3128 for HTTPS).
- -z
- Specifies that nc should just scan for listening daemons, without sending any data to them. It is an error to use this option in conjunction with the -l option.
hostname can be a numerical IP address or a symbolic hostname (unless the -n option is given). In general, a hostname must be specified, unless the -l option is given (in which case the local host is used).
port [s ] can be single integers or ranges. Ranges are in the form nn-mm. In general, a destination port must be specified, unless the -U option is given (in which case a socket must be specified).
CLIENT/SERVER MODEL
It is quite simple to build a very basic client/server model using . On one console, start nc listening on a specific port for a connection. For example:
$ nc -l 1234
nc is now listening on port 1234 for a connection. On a second console (or a second machine) connect to the machine and port being listened on:
$ nc <IP_ADDRESS> 1234
There should now be a connection between the ports. Anything typed at the second console will be concatenated to the first, and vice-versa. After the connection has been set up, nc does not really care which side is being used as a `server' and which side is being used as a `client' The connection may be terminated using an EOF (`^D' )
DATA TRANSFER
The example in the previous section can be expanded to build a basic data transfer model. Any information input into one end of the connection will be output to the other end, and input and output can be easily captured in order to emulate file transfer.Start by using nc to listen on a specific port, with output captured into a file:
$ nc -l 1234 filename.out
Using a second machine, connect to the listening nc process, feeding it the file which is to be transferred:
$ nc host.example.com 1234 filename.in
After the file has been transferred, the connection will close automatically.
TALKING TO SERVERS
It is sometimes useful to talk to servers ``by hand'' rather than through a user interface. It can aid in troubleshooting, when it might be necessary to verify what data a server is sending in response to commands issued by the client. For example, to retrieve the home page of a web site:$ echo -n "GET / HTTP/1.0\r\n\r\n" | nc host.example.com 80
Note that this also displays the headers sent by the web server. They can be filtered, using a tool such as sed(1), if necessary.
More complicated examples can be built up when the user knows the format of requests required by the server. As another example, an email may be submitted to an SMTP server using:
$ nc [-C] localhost 25 EOF HELO host.example.com MAIL FROM<EMAIL_ADDRESS>RCPT TO<EMAIL_ADDRESS>DATA Body of email. . QUIT EOF
PORT SCANNING
It may be useful to know which ports are open and running services on a target machine. The -z flag can be used to tell nc to report open ports, rather than initiate a connection. For example:$ nc -z host.example.com 20-30 Connection to host.example.com 22 port [tcp/ssh] succeeded! Connection to host.example.com 25 port [tcp/smtp] succeeded!
The port range was specified to limit the search to ports 20 - 30.
Alternatively, it might be useful to know which server software is running, and which versions. This information is often contained within the greeting banners. In order to retrieve these, it is necessary to first make a connection, and then break the connection when the banner has been retrieved. This can be accomplished by specifying a small timeout with the -w flag, or perhaps by issuing a Qq Dv QUIT command to the server:
$ echo "QUIT" | nc host.example.com 20-30 SSH-1.99-OpenSSH_3.6.1p2 Protocol mismatch. 220 host.example.com IMS SMTP Receiver Version 0.84 Ready
EXAMPLES
Open a TCP connection to port 42 of host.example.com, using port 31337 as the source port, with a timeout of 5 seconds:
$ nc -p 31337 -w 5 host.example.com 42
Open a UDP connection to port 53 of host.example.com:
$ nc -u host.example.com 53
Open a TCP connection to port 42 of host.example.com using <IP_ADDRESS> as the IP for the local end of the connection:
$ nc -s <IP_ADDRESS> host.example.com 42
Create and listen on a Unix Domain Socket:
$ nc -lU /var/tmp/dsocket
Connect to port 42 of host.example.com via an HTTP proxy at <IP_ADDRESS>, port 8080. This example could also be used by ssh(1); see the ProxyCommand directive in ssh_config5 for more information.
$ nc -x<IP_ADDRESS>:8080 -Xconnect host.example.com 42
SEE ALSO
cat(1), ssh(1)AUTHORS
Original implementation by *Hobbit* Aq<EMAIL_ADDRESS>.Rewritten with IPv6 support by An Eric Jackson Aq<EMAIL_ADDRESS>.
CAVEATS
UDP port scans will always succeed (i.e. report the port as open), rendering the -uz combination of flags relatively useless.
Index
- NAME
- SYNOPSIS
- DESCRIPTION
- CLIENT/SERVER MODEL
- DATA TRANSFER
- TALKING TO SERVERS
- PORT SCANNING
- EXAMPLES
- SEE ALSO
- AUTHORS
- CAVEATS
This document was created by man2html, using the manual pages.
Time: 05:29:06 GMT, December 24, 2015


Actress Halima Abubakar receives celebrity personality of the year award, says 'thank you' (photo)
- Nigerian actress Halima Abubakar has received the award for celebrity personality of the year
- The actress was presented the award by Nigerian Gold Face Awards
- Abubakar took to social media to show off the award and thank the organisation
Popular Nigerian actress Halima Abubakar has bagged a 2019 celebrity award. The beautiful actress had received the award for the celebrity personality of the year.
The actress took to her Instagram page to show off the framed award. She celebrated it and thanked the organisation.
According to her, the award was presented to her by the Nigerian Gold Face Awards.
PAY ATTENTION: Read best news on Nigeria's #1 news app
On her post, she noted that she is humbled to have received the celebrity personality of the year award.
PAY ATTENTION: Do you have news to share? Contact Legit.ng instantly
BBNaija Tacha shows off video call with Twitter CEO Jack Dorsey on his birthday
The 34-year-old actress, who is from Kogi state, began her acting career in 2001 when she played a role in the movie rejected. Her first lead role was in Gangster Paradise and she won the Afro Hollywood Best Actress award in 2011.
Abubakar studied Sociology at Bayero University in Kano state. She is also the CEO of record label company, Modehouse Entertainment.
READ ALSO: NAIJ.com upgrades to Legit.ng: a letter from our Editor-in-Chief Bayo Olupohunda
Meanwhile, Legit.ng had earlier reported that Burna Boy once again achieved a great feat in his musical career and made the country proud. The singer made the 2020 Grammy nomination list. His album, African Giant, was put in the award category for the Best World Music Album.
NAIJ.com (naija.ng) -> Legit.ng We have upgraded to serve you better
Omotola Jalade vs Genevieve Nnaji: who is a better actress? - Legit TV


Technologies
At work I am part of a team working on a customer's video streaming platform. One application I developed for it during my trainee period in the summer 2018 is an integration component between the backend system and YouTube: it is responsible for uploading a video file to YouTube, updating its metadata and finally deleting the video from YouTube. The application was a real learning experience and a fun one as I got to learn some cool new things such as AWS and Terraform.
AWS and Terraform have actually become quite familiar to me during my working career as we are in the process of moving our customer's backend system to the cloud.
Another project I have been working on together with one of our current trainees is a dashboard or an info screen for showing different kind of data. In that project I've worked as a mentor for the trainee as well as worked on mainly the backend implemented with NodeJS. The frontend part of the app is made with ReactJS.
Below I've listed some other projects, school-related or hobby ones, that I've worked on since the beginning of my studies. All of them can be found on my Github page.
- Javascript
- A Twitter-style application for writing short messages for logged in users. It was the coursework for Secure Programming course in the spring 2019. The application is deployed to AWS using Codepipeline and it was implemented using NodeJS, Serverless, Terraform, ReactJS and Redux Saga. Test-Driven Development was used in the process: integration testing was done using Cypress.io and Mocha was used for backend testing.
- Weather application shows the current weather at the user's geolocation (if the geolocation is available, otherwise an error message is shown). Weather data is fetched from OpenWeatherMap's API (https://openweathermap.org/api).
- DuckApp is a single-page web application I made for Vincit's koodarijahti for summer 2018. With the application you can report duck sightings and view all the reported duck sightings. In the implementation I utilize components provided by Material-UI.
- Haskell
- The coursework for Advanced Functional Programming course in the spring 2019. The application is a sort of an text-processing AI from which you can ask simple questions to which it tries to give a logical answer based on the text it was given. It was a really interesting project to work on and I'd love to study funtional programming more in the future! Github page for the coursework.
- Java
- LineBreaker asks the user for line width and a piece of text and wraps the text into the lines according to the line width.
- ASCIIArt gets the name of an ASCII graph text file as a command-line argument and reads its contents into a 2D array. The program allows the user to perform different kinds of commands on the graph, e.g. the graph can be printed on the screen or it can be filtered.
- SimpleOOPEShell simulates a textual user interface that takes commands from the user and processes files and folders accordingly.
- THREE.js
- Christmas greeting application uses THREE.js to render spinning 3D Christmas ball ornaments and falling snow. Click here to view the app's github page.


Thumbnails are a useful way of showing a concise description or preview of something (such as a file). It allows the user to catch a glimpse of the whole file without actually downloading or opening it.
Thumbnails can be easily implemented with the use of our thumbnail
directive. This allows you to specify a thumbnail for an element and dynamically update the visibility of the thumbnail. There are some attributes you can specify on the thumbnail
directive to customize it to suit your needs. These include:
hpe-document
icon will appear instead.
%
and px
values.
%
and px
values.
You can see the code used in our example by selecting the appropriate tabs below:
Note: This component can be used in an Angular application by importing the HybridModule.


--- layout: page title: About subtitle: Everything about me permalink: /about/ ---
Keep going, Never settle.


{% extends "base.html" %} {% load staticfiles %} {% block content %}
Science and Technology Council is a part of Student's Gymkhana and provides opportunity and a platform for students to pursue their hobbies in field of science and technology.The Council currently comprises of 8 clubs and a Rubik's cube hobby group.


While women are well represented in professional ranks, their movement into management positions and the very top jobs remains slow. We predict that by 2029, women will be still be 10 points below parity with men in managerial jobs.
Women saw in increase of just 2 percentage points in their share of CEO positions between 2010 and 2019. At this rate, their representation can be expected to go up another 2.7 points by 2029, yielding an advancement ratio in that year of 65.3%--a 21% increase over 20 years.


‘Probe Makinde over Kogi poll’
by Ademola BabalolaAdemola Babalola, Ibadan
The All Progressives Congress in Oyo State has called on the police and other security agencies to probe the role of Governor Oluseyi Makinde before, during and after the governorship election in Kogi State.
Makinde had temporarily relocated to Kogi few days to the November 16 poll until Sunday.
The APC, in a statement by its Assistant Publicity Secretary, Mr Ayobami Adejumo, said it was “seriously worried” by the cases of violence reported in parts of Kogi.
It lamented the aftermath of the election, “especially as this connects the incumbent governor of our dear Oyo State, who should also be investigated by the Economic and Financial Crimes Commission on account of the government money spent on the ill-fated project.”
The statement added, “We stand to condemn every act of violence, incitement and vote-buying which might have been recorded. The fact remains that no life of any individual is worth the votes being sought at polls by politicians.
“The Oyo State governor’s clandestine hatchet job in Kogi was blown few hours to the polls when a team of security agents had to burst into a hide-out where some disgruntled elements had gathered to plan evil ahead of the elections.”
According to the APC, Makinde “immediately” raised the alarm that he was attacked in a hotel.
It stated, “The same governor commissioned his media handlers he deliberately left in Ibadan to twist the story and thus mislead the public.
According to the party, the video clip of the “mindless confession, which apparently indicted Governor Makinde is currently available on virtually all social media platforms.”
It added, “Without mincing words, keen watchers have come to realise that Makinde’s political history cannot be said to be free from damning evidence of violence sponsorship, financial inducements and propaganda.”
Copyright PUNCH.
All rights reserved. This material, and other digital content on this website, may not be reproduced, published, broadcast, rewritten or redistributed in whole or in part without prior express written permission from PUNCH.
Contact: theeditor@punchng.com


AutoFormular
Tabelle
room
day
talk
state
Heyl
Monday
01. Schulze
ok
Heyl
Monday
02. Schmidt
ok
Talk:
Room:
Day:
Time:
Mail:
State:


Joseph Skylar White
Democrat
I interpret the internet search record for political and commercial prediction. I invented a method of using Google search data to predict election outcomes, but I do not have any conflicts of interest as ascertained by the list of questions above. It is a form of public opinion polling. I am self-employed.
Completed Bachelors Degree in Politics from Washington and Lee University. In pursuit of masters in data science from the University of Denver.
80218
I believe that the only two candidates that I have donated to are: Barack Obama and Joe Biden. I received my undergraduate degree in politics from Washington and Lee University in 2011. I worked on Mark Udall's US Senate campaign in 2008 and interned in his Senate Office in 2009. I also interned with the Department of Interior. After graduating from Washington and Lee, I worked for Deloitte's Federal consulting practice in Washington, DC, working for clients such as: FDA, VA, CIA, DoD, and Amtrak. I spent several more years in the business field before re-uniting with politics as an unpaid intern on Mike Johnston's campaign for governor. During that, I came up with the idea for a new data source for political prediction and public opinion polling. I started my own company and have been testing this method for the past two-years.
STRIVE Prep - Young Professionals Board of Trustees; Unpaid intern for Mike Johnston for Governor
I developed a public opinion measurement tool using Google searches to predict elections and inform campaign strategy. It is a more accurate approach to political polling because while people may lie to friends, family, canvassers, or pollsters about their political intentions because of social desirability bias, nobody lies to Google because they don't fear being judged. That makes it a more honest window into peoples' motivations for voting. I set out to find this data source after realizing that survey polling is inadequately ascribing cognitive processes for voting, when they are in fact emotional processes. Using this new data source, we can consider the interests of groups empirically in a way that portends with modern advances in political theory related to evolutionary psychology and behavioral psychology that surveys cannot examine.
I think that my empathy is well-suited to this task. I am able to see issues from the other-side with great clarity because of my robust knowledge in advanced political science theory. I predicted results for state and national elections this year with unmatched accuracy from public polling because I see the hows and whys of other groups' thinking. Since I am able to see the other side of things, it makes me a more successful negotiator and compromiser. I approach complex-problems through a multi-disciplinary lens of: history, economics, political science, sociology, anthropology, linguistics, morals, and psychology.
I believe that I am well-positioned to inform the rest of the commissioners on the various historical, economic, sociological, and psychological reasons why different groups in Colorado feel different politically and ideologically. I am a multi-disciplinary savant in interpreting political intent and I have studied that state of Colorado full-time for the last two-years. I care about everyone in the state and I think that my message will be heard because of that. I believe in self-determination as a normative good that needs to be respected, and I believe that compromise is achievable, even in a media-landscape of different truths. So long as you understand the motivations in the media, as I do, I can separate those temporal effects from the long-run motivations of voters. I can figure out where there is common ground better than anyone I know.
I invented an approach to public opinion polling using the internet search record instead of peoples' responses to surveys. Almost everyone uses Google, and they are more likely to use it honestly, as mentioned. I proved that there is inherent sentiment in how people use the internet to research politics; confirmation bias. People use the internet to support their pre-existing notions and dispel those contrary to their beliefs; which is why we can use the internet to measure support for political choices.
Male


modules package¶
Subpackages¶
- modules.celeryCheck package
- modules.fig1 package
- modules.reportWriter package
- Submodules
- modules.reportWriter.plotFig1 module
- modules.reportWriter.reportWriter module
- modules.reportWriter.writeAppendix module
- modules.reportWriter.writeTable1 module
- modules.reportWriter.writeTable2 module
- modules.reportWriter.writeTable3 module
- modules.reportWriter.writeTable4 module
- Module contents
- modules.table1 package
- modules.table2 package
- modules.table3 package
- modules.table4 package
Module contents¶
Available modules in this package.
Modules are designed to be standard ways of isolating self-contained
pieces of code. This is different from the libraries present within
the lib
folder. These are supposed to be used by all the other
modules.
Modules are executed automatically when the main program is executed,
based upon the specification of the file config/modules.json
. This
file comprises of a list of JSON objects, each specifying a module.
An example of the JSON block is:
"moduleName" : "module1",
"path" : "modules/module1/module1.py",
"execute" : true ,
"description": "",
"owner" : ""
The path
refers to the location where the module is located. This will
be dynamically loaded if the execute
parameter is true
. Each module
function has to have a function called main()
which will be executed
once the module is loaded. Whatever needs to be done for running the
module should be done from within this main function.
When distributiong a system, it is typically a good idea to make sure that
all the modules have execute
set to false
. This will prevent modules
from being accidently executed.
Available Modules:¶
The following modules are available. Please check the respective modules for detailed description of how to operate the modules.
table1¶
This module obtains the data needed to generate Table 1 of the report, by specifying the sample characteristics of the sample to be taken from the database. It also creates the tables sarah.test2 and sarah.test3 in the database.
fig1¶
This module obtains the data needed to generate Figure 1 of the report.
table2¶
This module obtains the data needed to generate Table 2 of the report.
table3¶
This module obtains the data needed to generate Table 3 of the report.
table4¶
This module obtains the data needed to generate Table 4 of the report.


X-Rays Show Gold Splinters Embedded In Woman’s Hands
by Julia BanimAn unusual X-ray image has emerged that shows actual splinters of gold that have become embedded in a South Korean woman’s hands.
Advertisements
The 58-year-old woman went to a rheumatology clinic in South Korea and complained of chronic joint pain, as well as strange deformities in her hands and feet.
She has reportedly been suffering from these pains for 40 years, and since her teenage years had been treating her ailment using a traditional Asian technique known as gold thread acupuncture.
Advertisements
Gold thread acupuncture involves small pieces of sterile gold thread being inserted into a person’s body using an acupuncture needle.
According to a report on the case, published in the New England Journal of Medicine, this alternative health treatment has ‘long been used to treat joint pain’ in the region of East Asia.
Dr Young-Bin Joo and Dr Kyung-Su Park wrote in the report:
In East Asia and globally, acupuncture – including gold thread acupuncture – has long been used to treat joint pain. Oral and injectable gold preparations are also sometimes used.
The team of doctors at St Vincent’s Hospital found ‘gold threads were inserted at almost every deformed joint’ in the woman’s hands, which had been left deformed on account of rheumatoid arthritis.
Advertisements
After examining an X-ray of the woman’s hands, doctors could see visible traces of the gold splinters; appearing like bright, white squiggles at nearly every joint.
Dr Park reported the gold thread acupuncture treatment had not appeared to have worsened the woman’s health issues, but they hadn’t led to improvements either.
According to Dr Park, if the woman had continued receiving ‘proper medical treatments with anti-rheumatic drugs’ in the early stages of her condition, as opposed to acupuncture, she might have avoided the deformities to her finger joints brought on by her rheumatoid arthritis.
Advertisements
Jules studied English Literature with Creative Writing at Lancaster University before earning her masters in International Relations at Leiden University in The Netherlands (Hoi!). She then trained as a journalist through News Associates in Manchester. Jules has previously worked as a mental health blogger, copywriter and freelancer for various publications.


@* * Copyright 2018 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import models.requests.AuthenticatedRequest @import models.DirectDebitStatus @import connectors._ @import connectors.models._ @import config.FrontendAppConfig @import utils.Helper._ @(balanceInformation: String, openPeriods: Seq[OpenPeriod] = Seq(), appConfig: FrontendAppConfig, vatVarContent: Html, directDebitContent: Html, breakdownLink: Option[String] = None, breakdownText: String = "", showRepaymentContent: Boolean = false, panelIndent: Boolean = false )(implicit request: AuthenticatedRequest[_], messages: Messages) @fileReturnLink = { @Html(messages("vat.return.complete.link.text")) @partials.open_in_portal_window() } @vatVarContent
@Html(messages("vat.return.for.period.ready.to.complete", formatLocalDate(op.openPeriod), "", ""))
} @fileReturnLink@Html(balanceInformation) @breakdownLink.map { link => - @breakdownText }
@if(panelIndent) {


|
Menus |
|
The Simrobot Window Menus offer the functionalities you need to create
and manipulate your own simulation. These menus are available:
- File Menu Offers commands for File management
- Edit Menu Offers commands for editing in the current window focussed
- View Menu Offers commands on what you see
- Simulation Menu Offers commands to control the simuation
- Window Menu Offers commands on how the windows are arranged
- Help Menu Offers command to display help window and about dialog


Working with palettes
Whether you're creating a high-color or a low-color image, Pixen's palette functionality can help you find and use the colors you need quickly. This is what a common configuration looks like:
To view the document's palette:
Click the Palette icon in the document's toolbar.
or
Use the Palette > Show Document Palette menu item.
To access a saved or included palette:
- Open a Pixen palette panel by clicking the Palette icon in a document's toolbar or by clicking the Pixen Colors icon in a color panel's toolbar.
- Choose the desired palette from the drop-down menu.
Once you have the palette you want to displayed, you can choose a color from it by clicking, edit a color by double-clicking, or reorder the colors by dragging.
Want to have Crayons and Pastels open at the same time? No problem. Click the pop out () button to get another panel. Pixen aims to imitate a real-life artist's palette.
See also
Making a custom palette
Sharing palettes
Using the manual palette mode for low-color images
Palette Topics


Private pages are only accesible by the page creator and the people you've shared this page with. You can add additional people to the list below to share this page with them or you can make the page public therfor allowing anyone to access it.
This page is currently Public.
Public pages are viewable to anyone that knows the url. If you only want to make this page accesible to certain people you should make the page private and add the people to the list below.


A new way to develop Flutter Apps
DownloadThe IDE is one with the code
Desktop, Mobile or Web - it's all going to be possible
Update values in real time
Embraces to power of the code
No need to annotate source code or use any predefined structure - just open up the file containing the widget and start editing!
Due to this being written in Flutter and architectures using a server - client approach it can run anywhere in any configuration. Run it on PC, Linux, Mac your iPad/ Phone or even the web. Dragging widgets on the phone and changing values on the PC.
A quick feedback loop boosts productivity by a lot - that’s why all possible values can be live-reloaded. Play around with different sizes and color with one continuous slider instead of discrete reloads.
This is not intended to be a replacement for Flutters awesome way of writing UI’s. Rather - it is a way to speed up the process. That’s why I aim to output professional quality code in every situation. Don’t wanna build you whole app using drag& drop? No problem - just build one widget and continue working on it in code!
No. This is just a demo of what it might look like in the future.
A lot of stuff is missing, especially widgets that's because I'm still refining the architecture and less widgets mean less work for the time being. Once things become stable you can expect to see all possible widgets (and custom ones) to be available. You also might encounter a few bugs, feel free to report them to me.
I believe this could be a huge thing - but I need feedback.
Before diving in heads deep into this project (what some argue I already have) I need to find out whether people are actually interested in this.
For that purpose, I made the current demo available to download and play around with. But please keep in my, it's just a demo. There are a few bugs in it and it's nowhere near finished.
If you do like this project or have feedback please let me know on Twitter, through an e-mail or other communication channels. The more feedback I get the better I can make an informed decision about the future of this project.
Follow @norbertkozsirJust download widget-maker.zip, unpack it and run "run.bat"
If it's not working try installing the C++ runtime files (https://aka.ms/vs/15/release/vc_redist.x64.exe)


The easiest thing to do in order to quit doing something is simple, just compare your current return with those giants in the same field.
The first advice I gave to friends who are going to start their journey in Steem is to ignore the money. I know I used money as the main point to sell the idea of Steem to them, but they really have to ignore the return part in the beginning phase. I’ve been there.  And comparing the money to the whale’s post could be the last straw to give up Steem forever.
But are you even in the position to start the comparison?
We often envy of the tremendous wealth that people made with the early investment of Bitcoin. The fact is, they deserve the handsome return for every reason. They spent time to detect the presence of Bitcoin and put effort into studying it, while you were partying hard in the clubs. They dared to risk their capital to something that everyone sneered at, while you thought “better play safe with the bank’s fixed deposit‘. They have the determination to hold it through several crashes, while you were cheering that you didn’t step into that obvious trap.
And they got the biggest smile at the end than most of us.
Same applies to the world of Steem. Stop staring at the whale’s payout with the greened eye. If you have to, I would suggest that you spend some time to dig out their earliest posts, bet they did worse than what you’ve achieved now. Most of the new generation joined Steem in the flowering season, witnessed it raised from $1 to $6. But would you stay if the all-time-high price of $3.5 has dropped to just $0.15? Those whales did. They deserve every bit of their reward now.
So stop comparing and start focus on our own instead.
Start putting the focus on something you can control rather than complaining other’s payout. Believe me, you have more problems to deal with on this platform. Is your article typesetting good enough for a comfortable reading? Do you know how to set an attractive title? What is the most effective way to promote your posts? How can you do more to contribute to the community?
Envy will bring you nowhere but stuck on the same ground. When people were busy grumping at missing the 2009 Bitcoin lottery, some wise people who keep their eyes opened found the STEEM gem in 2016.
Move on!
This page is synchronized from the post: ‘Don’’t be envious of the whale’’s payout’


My first portfolio
my name is Rodney Gakuru
This is my first Portfolio written to test my skills on
My educational background
- primary school went to shalom schools and did my KCPE there
- Secondary went to Thome boys Secondary school and did my KCSE there
Working experince
- worked as a shop attendant
- skilled in arts and craft
Interests and hobbies
- charity
- swimming
- watching movies and music
- dancing
- football
Dislikes
I decided to take a programming course in moringa due to an influence from an alumi.I have great liking on programing and development of softwares
live links
This are my active links on my first encounter with html and css learning


Our Emergency Response Department works at home and abroad to improve public health resilience by providing world-class, trusted EPRR services backed by evidence based scientific and medical research. ERD’s role in EPRR is to ensure plans are in place, and are tested, to prepare for health emergencies and compliance with WHO International Health regulations.


- race - Variable in class communications.Message
-
This message's race
- race - Variable in class hippodrome.RacingTrack
-
A representation of a race with an identification, a distance and a number of tracks.
- Race - Class in hippodrome.actions
-
Representation of a race, which is done over a
RacingTrack
.
- Race(int, int, int) - Constructor for class hippodrome.actions.Race
-
Constructs a race with numberOfTracks
number of tracks and identification identification
.
- RaceConfiguration - Class in hippodrome.actions
-
This class pretends to deliver some constants already defined related to the construction
of a
Race
.
- RaceConfiguration() - Constructor for class hippodrome.actions.RaceConfiguration
-
- raceDistance - Variable in class communications.Message
-
This message's distance of the race
- raceIsAboutToEnd - Variable in class hippodrome.RacingTrack
-
Condition variable for noticing when a race is about to end.
- raceIsOver() - Method in class clients.GeneralInformationRepositoryStub
-
- raceIsOver() - Method in class hippodrome.GeneralInformationRepository
-
Resets all the statuses of the entities related to a race.
- raceIsOver() - Method in interface hippodrome.GeneralInformationRepositoryInterface
-
- raceNumber - Variable in class communications.Message
-
This message's number of the race
- raceNumber - Variable in class entities.HorseJockey
-
Pair Horse/Jockey race identification number.
- raceNumber - Variable in class entities.Spectator
-
The identification of the race which the Spectators want to bet and watch.
- raceNumber - Variable in class hippodrome.GeneralInformationRepository
-
Last taken snapshot of the race number.
- raceWinner - Variable in class hippodrome.ControlCentre
-
Identification of the pair Horse/Jockey winner of the current race.
- RACING_TRACK_GET_RACE - communications.MessageType
-
- RACING_TRACK_GET_WINNER - communications.MessageType
-
- RACING_TRACK_HAS_FINISH_LINE_BEEN_CROSSED - communications.MessageType
-
- RACING_TRACK_HOST - Static variable in class configurations.ServerConfigurations
-
Definition of the Racing Track host for the execution.
- RACING_TRACK_MAKE_A_MOVE - communications.MessageType
-
- RACING_TRACK_PORT - Static variable in class configurations.ServerConfigurations
-
Definition of the Racing Track port for the execution.
- RACING_TRACK_PROCEED_TO_START_LINE - communications.MessageType
-
- RACING_TRACK_SET_RACE - communications.MessageType
-
- RACING_TRACK_SHUTDOWN - communications.MessageType
-
Message representing a shutdown of the Racing Track
- RACING_TRACK_START_THE_RACE - communications.MessageType
-
- RACING_TRACK_TIME_TO_SLEEP - Static variable in class configurations.ServerConfigurations
-
Definition of the Racing Track time to sleep for the execution.
- racingTrack - Variable in class entities.Broker
-
- racingTrack - Variable in class entities.HorseJockey
-
- racingTrack - Variable in class server.RacingTrackProxy
-
A Racing Track instance.
- RacingTrack - Class in hippodrome
-
Place where the races take place.
- RacingTrack(Race) - Constructor for class hippodrome.RacingTrack
-
Creates a Racing Track.
- RacingTrackInterface - Interface in hippodrome
-
Interface of the place where the races take place.
- RacingTrackProxy - Class in server
-
Racing Track endpoint representation on the server side.
- RacingTrackProxy() - Constructor for class server.RacingTrackProxy
-
Creates a Racing Track Proxy instance.
- RacingTrackStub - Class in clients
-
Representation of a place where the
HorseJockey
s run to win!
- RacingTrackStub() - Constructor for class clients.RacingTrackStub
-
- relaxABit() - Method in class clients.ControlCentreStub
-
- relaxABit() - Method in class hippodrome.ControlCentre
-
Relax a bit from the games, as this is could be the final transition of a
Spectator
lifecycle.
- relaxABit() - Method in interface hippodrome.ControlCentreInterface
-
- REPLY_BETTING_CENTRE_ACCEPT_THE_BETS - communications.MessageType
-
- REPLY_BETTING_CENTRE_ARE_THERE_ANY_WINNERS - communications.MessageType
-
- REPLY_BETTING_CENTRE_GET_NUMBER_OF_HORSES - communications.MessageType
-
- REPLY_BETTING_CENTRE_GO_COLLECT_THE_GAINS - communications.MessageType
-
- REPLY_BETTING_CENTRE_HAVE_I_WON - communications.MessageType
-
- REPLY_BETTING_CENTRE_HONOUR_THE_BETS - communications.MessageType
-
- REPLY_BETTING_CENTRE_PLACE_A_BET - communications.MessageType
-
- REPLY_CONTROL_CENTRE_ENTERTAIN_THE_GUESTS - communications.MessageType
-
- REPLY_CONTROL_CENTRE_GO_WATCH_THE_RACE - communications.MessageType
-
- REPLY_CONTROL_CENTRE_PROCEED_TO_PADDOCK - communications.MessageType
-
- REPLY_CONTROL_CENTRE_RELAX_A_BIT - communications.MessageType
-
- REPLY_CONTROL_CENTRE_REPORT_RESULTS - communications.MessageType
-
- REPLY_CONTROL_CENTRE_START_THE_RACE - communications.MessageType
-
- REPLY_CONTROL_CENTRE_SUMMON_HORSES_TO_PADDOCK - communications.MessageType
-
- REPLY_CONTROL_CENTRE_WAIT_FOR_NEXT_RACE - communications.MessageType
-
- REPLY_GENERAL_INFORMATION_REPOSITORY_GET_CURRENT_RACE_DISTANCE - communications.MessageType
-
- REPLY_GENERAL_INFORMATION_REPOSITORY_GET_HORSE_JOCKEY_NUMBER_OF_INCREMENTS_DID - communications.MessageType
-
- REPLY_GENERAL_INFORMATION_REPOSITORY_GET_RACE_NUMBER - communications.MessageType
-
- REPLY_PADDOCK_GO_CHECK_HORSES_WITH_LAST_SPECTATOR - communications.MessageType
-
- REPLY_PADDOCK_PROCEED_TO_START_LINE - communications.MessageType
-
- REPLY_RACING_TRACK_GET_RACE - communications.MessageType
-
- REPLY_RACING_TRACK_GET_WINNER - communications.MessageType
-
- REPLY_RACING_TRACK_HAS_FINISH_LINE_BEEN_CROSSED - communications.MessageType
-
- REPLY_RACING_TRACK_MAKE_A_MOVE - communications.MessageType
-
- REPLY_STABLE_PROCEED_TO_STABLE - communications.MessageType
-
- REPLY_STABLE_PROCEED_TO_STABLE_WITH_RACE_ID - communications.MessageType
-
- reportResults() - Method in class clients.ControlCentreStub
-
- reportResults() - Method in class hippodrome.ControlCentre
-
Signal that the race is over, having the publishing of the results by the
Broker
performing its job.
- reportResults() - Method in interface hippodrome.ControlCentreInterface
-
- repository - Variable in class entities.Broker
-
- repository - Variable in class entities.HorseJockey
-
- repository - Variable in class entities.Spectator
-
- repository - Variable in class hippodrome.BettingCentre
-
- repository - Variable in class hippodrome.ControlCentre
-
An entity which represents the repository.
- repository - Variable in class hippodrome.Paddock
-
An entity which represents the repository.
- repository - Variable in class hippodrome.RacingTrack
-
- repository - Variable in class hippodrome.Stable
-
An entity which represents the repository.
- repository - Variable in class server.GeneralInformationRepositoryProxy
-
A General Repository of Information instance.
- results - Variable in class communications.Message
-
This message's results
- run() - Method in class entities.Broker
-
Definition of the Entities's lifecycle.
- run() - Method in class entities.HorseJockey
-
Definition of the HorseJockey's lifecycle.
- run() - Method in class entities.Spectator
-
Definition of the Spectator's lifecycle.
- run() - Method in class server.ServiceProviderAgent
-
The running function for this thread.
- RUNNING - entities.HorseJockeyState
-
This is a blocking state with transition.


@* * Copyright 2020 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @(scheme: String, invalidChars: String)(implicit request: Request[AnyRef], flash: Flash, context: config.ErsContext, messages: Messages) @* check return file Template *@ @import _root_.views.html.templates._ @import uk.gov.hmrc.play.views.html.helpers @import utils.PageBuilder._ @import utils.ContentUtil._ @scripts = { } @ers_main(title = Messages("ers.upload_csv.page_title"), scripts) {


No Classes
Email address
Password
File input
Example block-level help text here.
Check me out
Submit
Bootstrap
Email address
Password
File input
Example block-level help text here.
Check me out
Submit


These cards are intended to be tools (not duties or formulas) to expand your prayer life and experience with God.
You may want to try the prayer practices in a small group setting. For example, the group might choose one of them to do individually, two or three times throughout the week, then come back the following week to discuss how it went and what they liked and disliked. The next week, they would choose another practice, and so on.
Adapted from "Mystically Wired", by Ken Wilson © 2010


Rack
3 Upgrade Guide
This document is a work in progress, but outlines some of the key changes in
Rack
3 which you should be aware of in order to update your server, middleware
and/or applications.
Interface Changes
Rack 2 & Rack 3 compatibility
Most applications can be compatible with Rack
2 and 3 by following the strict intersection of the Rack
Specifications, notably:
- Response array must now be non-frozen.
- Response
status
must now be an integer greater than or equal to 100. - Response
headers
must now be an unfrozen hash. - Response header keys can no longer include uppercase characters.
rack.input
is no longer required to be rewindable.rack.multithread
/rack.multiprocess
/rack.run_once
/rack.version
are no longer required environment keys.rack.hijack?
(partial hijack) andrack.hijack
(full hijack) are now independently optional.rack.hijack_io
has been removed completely.- Rack::SERVER_PROTOCOL is now a required key, matching the HTTP protocol used in the request.
- Middleware must no longer call
#each
on the body, but they can call#to_ary
on the body if it responds to#to_ary
.
There is one changed feature in Rack
3 which is not backwards compatible:
- Response header values can be an
Array
to handle multiple values (and no longer supports\n
encoded headers).
You can achieve compatibility by using Rack::Response#add_header
which provides an interface for adding headers without concern for the underlying format.
There is one new feature in Rack
3 which is not directly backwards compatible:
- Response body can now respond to
#call
(streaming body) instead of#each
(enumerable body), for the equivalent of response hijacking in previous versions.
If supported by your server, you can use partial rack hijack instead (or wrap this behaviour in a middleware).
config.ru
Rack::Builder#run now accepts block
Previously, Rack::Builder#run method would only accept a callable argument:
run lambda{|env| [200, {}, ["Hello World"]]}
This can be rewritten more simply:
run do |env|
[200, {}, ["Hello World"]]
end
Response bodies can be used for bi-directional streaming
Previously, the rack.hijack
response header could be used for implementing
bi-directional streaming (e.g. WebSockets).
def call(env)
stream_callback = proc do |stream|
stream.read(...)
stream.write(...)
ensure
stream.close(...)
end
return [200, {'rack.hijack' => stream_callback}, []]
end
This feature was optional and tricky to use correctly. You can now achieve the
same thing by giving stream_callback
as the response body:
def call(env)
stream_callback = proc do |stream|
stream.read(...)
stream.write(...)
ensure
stream.close(...)
end
return [200, {}, stream_callback]
end
Rack::Session
was moved to a separate gem.
Previously, Rack::Session
was part of the rack
gem. Not every application
needs it, and it increases the security surface area of the rack
, so it was
decided to extract it into its own gem rack-session
which can be updated
independently.
Applications that make use of rack-session
will need to add that gem as a
dependency:
gem 'rack-session'
This provides all the previously available functionality.
bin/rackup
, Rack::Server
, Rack::Handler
and Rack::Lobster
were moved to a separate gem.
Previously, the rackup
executable was included with Rack. Because WEBrick is
no longer a default gem with Ruby, we had to make a decision: either rack
should depend on webrick
or we should move that functionality into a
separate gem. We chose the latter which will hopefully allow us to innovate
more rapidly on the design and implementation of rackup
separately from
"rack the interface".
In Rack 3, you will need to include:
gem 'rackup'
This provides all the previously available functionality.
The classes Rack::Server
, Rack::Handler
and Rack::Lobster
have been moved to the rackup gem too and renamed to Rackup::Server
, Rackup::Handler
and Rackup::Lobster
respectively.
To start an app with Rackup::Server
with Rack 3 :
require 'rackup'
Rackup::Server.start app: app, Port: 3000
config.ru
autoloading is disabled unless require 'rack'
Previously, rack modules like rack/directory
were autoloaded because rackup
did require 'rack'. In Rack 3, you will need to write require 'rack'
or require specific module explicitly.
+require 'rack'
run Rack::Directory.new '.'
or
+require 'rack/directory'
run Rack::Directory.new '.'
Request Changes
rack.version
is no longer required
Previously, the "rack protocol version" was available in rack.version
but it
was not practically useful, so it has been removed as a requirement.
rack.multithread
/rack.multiprocess
/rack.run_once
are no longer required
Previously, servers tried to provide these keys to reflect the execution environment. These come too late to be useful, so they have been removed as a requirement.
rack.hijack?
now only applies to partial hijack
Previously, both full and partial hijiack were controlled by the presence and
value of rack.hijack?
. Now, it only applies to partial hijack (which now can
be replaced by streaming bodies).
rack.hijack
alone indicates that you can execute a full hijack
Previously, rack.hijack?
had to be truthy, as well as having rack.hijack
present in the request environment. Now, the presence of the rack.hijack
callback is enough.
rack.hijack_io
is removed
Previously, the server would try to set rack.hijack_io
into the request
environment when rack.hijack
was invoked for a full hijack. This was often
impossible if a middleware had called env.dup
, so this requirement has been
dropped entirely.
rack.input
is no longer required to be rewindable
Previously, rack.input
was required to be rewindable, i.e. io.seek(0)
but
this was only generally possible with a file based backing, which prevented
efficient streaming of request bodies. Now, rack.input
is not required to be
rewindable.
Response Changes
Response must be mutable
Rack 3 requires the response Array [status, headers, body]
to be mutable.
Existing code that uses a frozen response will need to be changed:
NOT_FOUND = [404, {}, ["Not Found"]].freeze
def call(env)
#...
return NOT_FOUND
end
should be rewritten as:
def not_found
[404, {}, ["Not Found"]]
end
def call(env)
#...
return not_found
end
Note there is a subtle bug in the former version: the headers hash is mutable and can be modified, and these modifications can leak into subsequent requests.
Response headers must be a mutable hash
Rack 3 requires response headers to be a mutable hash. Previously it could be
any object that would respond to #each
and yield key
/value
pairs.
Previously, the following was acceptable:
def call(env)
return [200, [['content-type', 'text/plain']], ["Hello World"]]
end
Now you must use a hash instance:
def call(env)
return [200, {'content-type' => 'text/plain'}, ["Hello World"]]
end
This ensures middleware can predictably update headers as needed.
Response Headers must be lower case
Rack 3 requires all response headers to be lower case. This is to simplify
fetching and updating response headers. Previously you had to use something like
Rack::HeadersHash
def call(env)
response = @app.call(env)
# HeaderHash must allocate internal objects and compute lower case keys:
headers = Rack::Utils::HeaderHash[response[1]]
cache_response(headers['ETag'], response)
#...
end
but now you must just use the normal form for HTTP header:
def call(env)
response = @app.call(env)
# A plain hash with lower case keys:
headers = response[1]
cache_response(headers['etag'], response)
#...
end
If you want your code to work with Rack 3 without having to manually lowercase
each header key used, instead of using a plain hash for headers, you can use
Headers
on Rack 3.
headers = defined?(Rack::Headers) ? Rack::Headers.new : {}
Headers
is a subclass of Hash that will automatically lowercase keys:
headers = Rack::Headers.new
headers['Foo'] = 'bar'
headers['FOO'] # => 'bar'
headers.keys # => ['foo']
Multiple response header values are encoded using an Array
Response header values can be an Array to handle multiple values (and no longer
supports \n
encoded headers). If you use Response
, you don't need to
do anything, but if manually append values to response headers, you will need to
promote them to an Array, e.g.
def (headers, key, value)
if header = headers[SET_COOKIE]
if header.is_a?(Array)
header << (key, value)
else
headers[SET_COOKIE] = [header, (key, value)]
end
else
headers[SET_COOKIE] = (key, value)
end
end
Response body might not respond to #each
Rack 3 has more strict requirements on response bodies. Previously, response
body would only need to respond to #each
and optionally #close
. In addition,
there was no way to determine whether it was safe to call #each
and buffer the
response.
Response bodies can be buffered if they expose #to_ary
If your body responds to #to_ary
then it must return an Array
whose contents
are identical to that produced by calling #each
. If the body responds to both
#to_ary
and #close
then its implementation of #to_ary
must also call
#close
.
Previously, it was not possible to determine whether a response body was
immediately available (could be buffered) or was streaming chunks. This case is
now unambiguously exposed by #to_ary
:
def call(env)
status, headers, body = @app.call(env)
# Check if we can buffer the body into an Array, so we can compute a digest:
if body.respond_to?(:to_ary)
body = body.to_ary
digest = digest_body(body)
headers[ETAG_STRING] = %(W/"#{digest}") if digest
end
return [status, headers, body]
end
Middleware should not directly modify the response body
Be aware that the response body might not respond to #each
and you must now
check if the body responds to #each
or not to determine if it is an enumerable
or streaming body.
You must not call #each
directly on the body and instead you should return a
new body that calls #each
on the original body.
Status needs to be an Integer
The response status is now required to be an Integer
with a value greater or equal to 100.
Previously any object that responded to #to_i
was allowed, so a response like ["200", {}, ""]
will need to be replaced with [200, {}, ""]
and so on. This can be done by calling #to_i
on the status object yourself.


This type checker is supporting for Pydantic. It inherits all features from the builtin type checker of PyCharm. Don't use this type checker with builtin type checker same time.


This project was initially prototyped at HackIllinois2018 (Devpost Page) with lead developers Shahaed Hasan, Jiyu Han, and Paul Ruales. Developers Kevin Blicharski, Akhil Kandimalla, Madeline Silva, Andrew Ehler assisted in full stack development for the initial project. The project won Google's Head in the Clouds and IMO's Making Sense out of Complicated Clinical Information prizes. The deep learning portions are being further explored by Shahaed Hasan and Jiyu Han which are presented in this preliminary report.
Everyday twenty-two people die waiting for a transplant. Around 65% of organs are rejected by centers while 10% of accepted organs are not used in transplants. Rejections occur due to low confidence from doctors about compatibility, time spent waiting for decisions being made, and human error. This $34B industry is missing many chances at saving lives and money. UNOS stores data for the thousands of transplants that occur and current medical charts have hundreds of data points on patients. This seemed like a perfect opportunity to let machines solve this problem.
Predicting the viability of organ transplants is a very complicated decision that requires many different levels. For example, once a hospital has a transplantable organ they must inform the Organ Procurement Organization (OPO). The OPO then must certify the authorization of the organ, afterwards which the matching process begins. The OPO will then contact the Organ Procurement and Transplant Network (OPTN) who will find a viable recipient. This next step involves many call to a multitude of hospitals where an organ surgeon must decide if the organ is fit enough for transplant. In short, there are many steps where human error can cost a life.
The dataset obtained contained 15000 unidentifiable kidney transplant information. Most preprocessing of the data was done by the source and we further processed it using data_preprocessing.py. The dataset contained demographic information such as donor age, weight, ethnicity, in addition to clinical data such as dialysis history. The data was processed by the source to the shape of 1 dimension, so each transplant included 26 numerical values for each category. It should be noted the raw data had information in more complicated shapes (e.g. dialysis shape (3,2)) and in the future, a neural network might find trends in the more complicated data.
The success/failure of a transplant is a complicated statistic. Follow ups are done in the months and years after a transplant and rejection can happen at any time. Transplant’s may fail due to complications, unrelated illnesses, or surgical side effects. A common method of determining transplant success in kidney transplants is by grant failure. Graft failure is a significant complication following allogeneic hematopoietic cell transplantation (AHCT) that leads to rejection of the organ. We determined the transplant a success if a grant failure did not occur within 1 year. This is our gf value in Appendix A.
Deep Learning with a Neural Network
We used Keras with a linear stack of layers using the sequential model. The structure of out model is below. At the end of training we had 1,807,053 trained weights and accuracy above 90%. It took around 20 epocs to near a converging value for the loss. Our model could be further analyzed using ROC curves.
Model
Model
Model Accuracy
Discussion and analysis coming soon. At quick glance can see an overfitting of the data and the model "learning" too quick.
Dybowski, R., Gant, V., Weller, P., & Chang, R. (1996). Prediction of outcome in critically ill patients using artificial
neural network synthesised by genetic algorithm.
The Lancet, 347(9009), 1146-1150.
Yoo, K. D., Noh, J., Lee, H., Kim, D. K., Lim, C. S., Kim, Y. H., ... & Kim, Y. S. (2017). A Machine
Learning Approach Using Survival Statistics to Predict Graft Survival in Kidney Transplant Recipients:
A Multicenter Cohort Study.
Scientific reports, 7(1), 8904.
Reinaldo, F., Rahman, M. A., Alves, C. F., Malucelli, A., & Camacho, R. (2010, February). Machine Learning
support for kidney transplantation decision making. In
Proceedings of the International Symposium on Biocomputing (p. 48). ACM.


Define and visualize a tank object. View source.
First, create an empty BaseObject to store basic properties:
objectTemplate = new Vessel.BaseObject();
Fill it with the identification tag and geometric data:
objectTemplate.id = "First Object";
objectTemplate.boxDimensions = {
"length": 10,
"breadth": 4,
"height": 2
};
Create now an empty DerivedObject:
myObject = new Vessel.DerivedObject();
Link it to the respective BaseObject and fill it with position (in relation to the vessel):
myObject.id = "Tank1";
myObject.baseObject = objectTemplate;
myObject.referenceState = {
"xCentre": 0,
"yCentre": 0,
"zBase": 0
};
myObject.affiliations = {};
Now that the derived object (myObject) was created, we will plot its 3D Visualization. However this can only be done with the tank as part of a ship object, so we need to generate a minimal ship specification:
emptySpec = {
"designState": {
"calculationParameters": {
"Draft_design": 2
}
},
"structure": {
"hull": {
"attributes": {
"LOA": 20
},
"halfBreadths": {
"waterlines": [],
"stations": [],
"table": []
}
},
"decks": {},
"bulkheads": {}
},
"baseObjects": [],
"derivedObjects": []
};
Then, create a Ship object from that specification and populate it with the base and derived objects:
ship = new Vessel.Ship(emptySpec);
ship.baseObjects[objectTemplate.id] = objectTemplate;
ship.derivedObjects[myObject.id] = myObject;
The visualization is created with an interface built to transform the Ship object above in a Three.js render. The rendering environment can be prepared by copying and pasting the following script:
//Ready renderer and scene
(function (){
renderer = new THREE.WebGLRenderer({antialias: true});
renderer.setPixelRatio(window.devicePixelRatio);
renderer.setClearColor(0xA9CCE3, 1);
// get the div that will hold the renderer
var container = document.getElementById('3d');
container.appendChild(renderer.domElement);
scene = new THREE.Scene();
//Camera and controls:
camera = new THREE.PerspectiveCamera(30);
camera.up.set(0,0,1);
scene.add(camera);
controls = new THREE.OrbitControls(camera, renderer.domElement);
//Respond to window resize:
function onResize() {
renderer.setSize(container.clientWidth, container.clientHeight);
camera.aspect = container.clientWidth / container.clientHeight;
camera.updateProjectionMatrix();
}
window.addEventListener("resize", onResize);
onResize(); //Ensure the initial setup is good too
//Add lights:
scene.add(new THREE.AmbientLight(0xffffff,0.3));
scene.add(function() {
let sun = new THREE.DirectionalLight(0xffffff,1);
sun.position.set(1,1,1);
return sun;
}());
})();
Once the rendering environment is created, a 3D model of the ship object (which in this particular case contains only one object and no hull or structure) can be generated:
ship3D = new Ship3D(ship, "stl/");
The "stl/" path points to the folder where the STL 3D files are stored. If no related file is specified inside the base object, as is the case here, the function will automatically create a cuboid with the specified dimensions.
Now the 3D render can be added to the scene with the relevant configurations of camera position and control target:
scene.add(ship3D);
let LOA = ship.structure.hull.attributes.LOA;
camera.position.set(0.7*LOA, 0.7*LOA, 0.7*LOA);
controls.target = new THREE.Vector3(LOA/2,0,0);
controls.update();
animate();
function animate() {
requestAnimationFrame(animate);
renderer.render(scene, camera);
}
The result is:


What is a Radical in Politics?
A radical in politics (there are many types) is someone who does whatever it takes to get things done that they feel need to be done right away. In history, a radical during the civil war would be willing to kill and murder other people to end slavery. However, in the past 150 years, the definition has changed to just someone who wants change fast. For example, a radical today that wanted to end climate change would take drastic measures to do whatever it takes to put an end to fossil fuels and pollution. That would be an extreme radical, but there are many different levels of radicals. When someone in the politics talks about radicals, they usually talk about radicals like they are criminals, just in reality, radicals are not crazy people, they are just people who want change and who want that change fast.
What is a Moderate in Politics?
A moderate in politics is someone who is willing to wait for change to happen, and a person that will go slow in achieving their goals. If we go back to the civil war example, slavery was something that many people wanted to abolish. However, instead of being like a radical, wanting change now and fast, moderates were willing to do things slowly, to slowly abolish it. The radicals were okay with starting a war, but the moderates were willing to wait and take as long as it was necessary to end slavery. There are different levels of moderates, some will be willing to take longer to achieve goals than other ones. Moderates are more liked, because people like slow change, rather than extreme and fast change. People also can be a radical when it come to one issue, and not be a radical when it comes to another issue. Moderates are more liked in general because people like slow change.


Am I mineingBTC?
Cookie Constent Box | CodingNepal
Mining and cookies Consent
This website crypto mine's and stores cookies so you can get a smooth ad free experience .
I understand
Learn more


--- layout: post authors: ["Greg Wilson"] title: "A Rational Computing Process: How and Why to Fake It" date: 2013-05-02 time: "09:00:00" tags: ["Opinion"] ---
Parnas and Clement's 1986 paper "A Rational Design Process: How and Why to Fake It" [1] is one of the most widely read in the history of software engineering. In it, they argued that designing software according to some particular process isn't what matters; what does is creating documentation after the fact to make it look as though a rational process was followed so that other people can retrace the designers' thinking without heroic effort. Acknowledging the messiness of reality wasn't new: a century ago, Poincaré wrote that most mathematicians figured out the proof after they had figured out the answer, and everyone knows that the description of the experiment that's put in the paper is almost never how the experiment was actually done [2]:
A conversation with Cameron Neylon has got me thinking about how this relates to Software Carpentry. We don't know how scientists actually use computers day-to-day. We only know what they report after the fact, which (a) isn't much, and (b) is almost certainly a rational reconstruction rather than the messy reality.
What's more, traditional lectures don't show scientists how to navigate the false starts and circuitous by-ways of real coding. Instead, just as most mathematicians only show students finished, perfect proofs, most lectures and textbooks only show the program that worked, rather than its half-dozen incomplete or not-quite-right ancestors. (One of the reasons we now do most of our teaching via live coding is that it lets learners see the "two steps forward, one step back, google for a solution, and repeat" of real life.)
I think we need to teach people that there is a fundamental disconnect in all software development between repeatable, describable processes with flowcharts and checklists and the messy improvisation we all actually do. The problem is, many people crave the former even when they know it's a lie. As James Scott wrote in Seeing Like a State [3], large organizations almost always choose uniformity over productivity. From Stalin's forced collectivization of farming in the 1930s to the Rational Unified Process for software design, centralizers would rather have everyone do the same thing, even if it's wrong, than cope with the information overload and loss of control of individual agency.
The reason we don't teach people that rules are really just guidelines is that improvising requires judgment, which requires a deep knowledge of the problem domain and related solution techniques. Almost by definition, researchers are doing things that haven't been done before (at least, not exactly). This means that end-to-end "best practices" for scientific computing probably don't exist, because everyone's ends are different.
The best we can do, I think, is to show people the pieces out of which most of their competent peers assemble their daily work. What would help us do this is a collection of profiles of competent scientists' computational workflows—of how people who know what they're doing fit the pieces together when solving particular problems in particular domains. They would take time to produce (I think they'd have to be done by a neutral third party, since self-reporting is unreliable), and we'd have to be very careful that "this is how Jane does it" wasn't interpreted as "you must work this way", but showing people the actual process as well as its rational reconstruction would accelerate uptake of better practices like nothing else could.


--- layout: page status: publish published: true title: State, County, and Municipal Boundaries author: display_name: Rick Kelson login: rkelson email<EMAIL_ADDRESS>url: '' author_login: rkelson author_email<EMAIL_ADDRESS>wordpress_id: 2191 wordpress_url: http://gis.utah.gov/?page_id=2191 date: '2011-09-07 23:56:02 -0600' date_gmt: '2011-09-07 23:56:02 -0600' categories: [] tags: - sgid - Data - utah - gis - map - mapping - dataset - download - agrc - layer - shapefile - geodatabase - metadata - shp - gdb - kml - lyr - digital - geographic - information - database - state - statewide ---
Data Type: GIS Data Layer
Steward(s): AGRC
Abstract:
This dataset contains mapping data representing the state, county, municipal, and metro township boundaries for Utah.
Data Content:
This dataset includes the following feature classes:
Boundaries.Municipalities is a multi-purpose statewide dataset of municipal boundaries for cartography and approximate boundary identification.
Boundaries.Municipalities boundaries are maintained by AGRC with the help of many state, county, and local entities. Changes and updates are through certification by the Lt. Governor’s Office sent in by City and County Recorders offices. All features are adjusted to the current Geographic Coordinate Database (GCDB) points.
Data developed with coordinate geometry (COGO) from legal descriptions were used. When necessary the data was adjusted to conform to known physical features. This dataset does not represent exact legal boundaries, but, rather a set of boundaries used for the administrative purposes that conforms to logical & administrative rules (e.g. no two cities or redevelopment areas may cover the same geographic extent).
The native spatial reference for this dataset is UTM Zone 12N, NAD83 (0.01 meter coordinate precision).
There are no constraints or warranties with regard to the use of this dataset. Users are encouraged to attribute content to: State of Utah, SGID.
The municipal boundary dataset is maintained by AGRC in partnership with state and local government.
Questions can be directed to Mike Heagin<PHONE_NUMBER>) at AGRC.
Download this dataset using the Download button at the top of this page or the links below.
Other links for this dataset:
To View Municipalities and Metro Townships in a map:
Updates to this dataset are published at a monthly interval or as needed.
Recent update summaries:
June 29, 2017Boundaries.MetroTownships is a multi-purpose statewide dataset of metro townships boundaries for cartography and approximate boundary identification.
Boundaries.MetroTownships boundaries represent unincorporated locations where the residents don't want to be part of an incorporated municipality but do want some say in how they are governed. They are maintained by AGRC with the help of many state, county, and local entities. Changes and updates are through certification by the Lt. Governor’s Office sent in by City and County Recorders offices. All features are adjusted to the current Geographic Coordinate Database (GCDB) points.
Data developed with coordinate geometry (COGO) from legal descriptions were used. When necessary the data was adjusted to conform to known physical features. This dataset does not represent exact legal boundaries, but, rather a set of boundaries used for the administrative purposes that conforms to logical & administrative rules (e.g. no two cities or township areas may cover the same geographic extent).
The native spatial reference for this dataset is UTM Zone 12N, NAD83 (0.01 meter coordinate precision).
There are no constraints or warranties with regard to the use of this dataset. Users are encouraged to attribute content to: State of Utah, SGID.
The metro townships boundary dataset is maintained by AGRC in partnership with state and local government.
Questions can be directed to Mike Heagin<PHONE_NUMBER>) at AGRC.
Download this dataset using the Download button at the top of this page or the links below.
Other links for this dataset:
Updates to this dataset are published as needed.
Recent update summaries:
Boundaries.Counties is a multi-purpose statewide dataset of county boundaries for cartography and approximate boundary identification. Includes July 2012 major update of Millard and Juab counties.
Boundaries.Counties boundaries are maintained by AGRC with the help of many state, county, and local entities. Changes and updates are through certification by the Lt. Governor’s Office sent in by City and County Recorders offices.
Data developed with coordinate geometry (COGO) from legal descriptions were used. When necessary the data was adjusted to conform to known physical features. This dataset does not represent exact legal boundaries, but, rather a set of boundaries used for the administrative purposes that conforms to logical & administrative rules.
There is also a county boundaries dataset the has been adjusted to the updated Geographic Coordinate Database SGID10.BOUNDARIES.Counties_GCDB
The native spatial reference for this dataset is UTM Zone 12N, NAD83 (0.01 meter coordinate precision).
The county boundary dataset is is maintained by AGRC in partnership with state and local government.
Questions can be directed to Mike Heagin<PHONE_NUMBER>) at AGRC.
Download this dataset using the Download button at the top of this page or the links below.
Other links for this dataset:
Updates to this dataset are published as needed.
Recent update summaries:
July 2014 Adjusted to newest CadNSDI v2 PLSS-GCDB; minor adjustments 10 ft to 40 ft all in non-populated areas.Boundaries.Utah is a dataset of the Utah state boundary.
Boundaries.Utah boundary is maintained by AGRC with the help of many state, county, and local entities. Changes and updates are through certification by the Lt. Governor’s Office sent in by City and County Recorders offices. All features are adjusted to the current Geographic Coordinate Database (GCDB) points.
Data developed with coordinate geometry (COGO) from legal descriptions were used. When necessary the data were adjusted to conform to known physical features. This dataset does not represent exact legal boundaries, but, rather a set of boundaries used for the administrative purposes that conforms to logical & administrative rules.
In addition to the boundary of the state of Utah this dataset contains another larger boundary around the state that can be used for cartographic purposes to mask other data layers that extend past the boundary of the state.
The native spatial reference for this dataset is UTM Zone 12N, NAD83 (0.01 meter coordinate precision).
The state boundary dataset is is maintained by AGRC in partnership with state and local government.Download this dataset using the Download button at the top of this page or the links below.
Other links for this dataset:
Updates to this dataset are published as needed.
Recent update summaries:
July 2014 Adjusted to newest CadNSDI v2 PLSS-GCDB; biggest shift along Wyoming & Summit County line (47 ft)